Skip to content

G
gjjs-bd-common
Commit 68583db9 by gechengyang
Options

提交初始版本

parent 5d0d5e6d
Showing with 101 additions and 3388 deletions
gjjs-bd-business/pom.xml
......@@ -129,6 +129,61 @@
<version>12.1.0.2</version>
</dependency>
<dependency>
<groupId>org.sss</groupId>
<artifactId>eibs-container</artifactId>
<version>3.5.0</version>
<scope>system</scope>
<systemPath>${project.basedir}/lib/eibs-container-3.5.0.jar</systemPath>
</dependency>
<dependency>
<groupId>org.sss</groupId>
<artifactId>eibs-containerex</artifactId>
<version>1.0.0</version>
<scope>system</scope>
<systemPath>${project.basedir}/lib/eibs-containerex-1.0.0.jar</systemPath>
</dependency>
<dependency>
<groupId>org.sss.module.hibernate</groupId>
<artifactId>eibs-hibernatesupport</artifactId>
<version>2.0.0</version>
<scope>system</scope>
<systemPath>${project.basedir}/lib/eibs-hibernatesupport-2.0.0.jar</systemPath>
</dependency>
<dependency>
<groupId>org.sss.module.pojo</groupId>
<artifactId>eibs-pojosupport</artifactId>
<version>2.0.0</version>
<scope>system</scope>
<systemPath>${project.basedir}/lib/eibs-pojosupport-2.0.0.jar</systemPath>
</dependency>
<dependency>
<groupId>org.sss</groupId>
<artifactId>eibs-zulsupport</artifactId>
<version>3.0.0</version>
<scope>system</scope>
<systemPath>${project.basedir}/lib/eibs-zulsupport-3.0.0.jar</systemPath>
</dependency>
<dependency>
<groupId>cn.com.brilliance</groupId>
<artifactId>eibs-ext</artifactId>
<version>1.0.0</version>
<scope>system</scope>
<systemPath>${project.basedir}/lib/eibs-ext.jar</systemPath>
</dependency>
<dependency>
<groupId>cn.com.brilliance</groupId>
<artifactId>PsbcFileClient</artifactId>
<version>1.0.0</version>
<scope>system</scope>
<systemPath>${project.basedir}/lib/PsbcFileClient.jar</systemPath>
</dependency>
</dependencies>
<build>
......
gjjs-bd-business/src/main/java/com/ceb/gjjs/mda/manager/module/Smpmod.java
......@@ -1439,12 +1439,12 @@ public class Smpmod extends AbstractModule{
String nextSmhInr = MdaUtils.format(Platform.mdbCounter("smh"),"00000000");//转化之后的报文smhinr
String nextFileName = this.getStoreFileFullPathName(nextSmhInr,"sf2");//转化之后的报文存放路径
///TODO:外部方法编写
Object obj = MdaUtils.invoke("","",nextFileName,new ICallback() {
@Override
public Object invoke(Object... paramVarArgs) {
getRmt103Rcvbnk(paramVarArgs);
return null;
}
Object obj = MdaUtils.invoke("","",nextFileName,new ICallback() {
@Override
public Object invoke(Object... paramVarArgs) {
getRmt103Rcvbnk(paramVarArgs);
return null;
}
});
Map<String,String> map = new HashMap<String,String>();
if(obj instanceof Map)
......@@ -6930,7 +6930,8 @@ public class Smpmod extends AbstractModule{
}
if(tmpchn==null)
{
tmpchn = new Chn(this);
//tmpchn = new Chn(this);
tmpchn = new Chn();
Platform.esdbRead("eibs",tmpchn,new Argument("cod",channel));
if(ctx.getErrorCode()!=NO_ERROR)
{
......
gjjs-bd-business/src/main/java/com/ceb/gjjs/mda/resource/AbstractCommonResource.java
......@@ -55,6 +55,7 @@ public abstract class AbstractCommonResource<V extends BaseVO> {
public ResponseSet<V> executeRule(@PathVariable("rule") String rule,@RequestBody V req) {
String[] ruleArr = rule.split(",");
ResponseSet<V> res = getCommonService().executeRule(req,ruleArr);
System.out.println("res="+res.getRespCode()+"----"+res.getRespMsg());
return res;
}
......
gjjs-bd-business/src/main/resources/application-oracle.yml
......@@ -38,6 +38,40 @@ spring:
connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
# 合并多个DruidDataSource的监控数据
useGlobalDataSourceStat: false
test1:
driver-class-name: oracle.jdbc.driver.OracleDriver
url: jdbc:oracle:thin:@114.115.138.98:9400:XE
username: TEST
password: test
type: com.alibaba.druid.pool.DruidDataSource
# 下面为连接池的补充设置，应用到上面所有数据源中
# 初始化大小，最小，最大
# druid 配置: https://github.com/alibaba/druid/wiki/
#初始化链接数
initialSize: 1
minIdle: 1
maxActive: 20
# 配置获取连接等待超时的时间
maxWait: 60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
timeBetweenEvictionRunsMillis: 60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
minEvictableIdleTimeMillis: 300000
validationQuery: select 1 from dual
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
# 打开PSCache，并且指定每个连接上PSCache的大小
poolPreparedStatements: true
maxPoolPreparedStatementPerConnectionSize: 20
# 配置监控统计拦截的filters，stat用于监控界面，'wall'用于防火墙防御sql注入, slf4j用于druid记录sql日志
filters: stat,slf4j
#,wall
# 通过connectProperties属性来打开mergeSql功能；慢SQL记录
connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
# 合并多个DruidDataSource的监控数据
useGlobalDataSourceStat: false
redis:
host: 127.0.0.1
database: 0
......
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/CfxopnServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.CfxopnVO;
public class CfxopnServiceTest extends BaseTest{
@Autowired
private CfxopnService cfxopn;
@Test
public void initTest() throws IOException {
CfxopnVO req = null;
File file = Paths.get(testJsonDir, "cfxopn").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<CfxopnVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<CfxopnVO> response = cfxopn.init(req);
}
@Test
public void checkAllTest() throws IOException {
CfxopnVO req = null;
File file = Paths.get(testJsonDir, "cfxopn").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<CfxopnVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<CfxopnVO> response = cfxopn.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
CfxopnVO req = null;
File file = Paths.get(testJsonDir, "cfxopn").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<CfxopnVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<CfxopnVO> response = cfxopn.saveData(req);
}
@Test
public void pendingTest() throws IOException {
CfxopnVO req = null;
File file = Paths.get(testJsonDir, "cfxopn").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<CfxopnVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<CfxopnVO> response = cfxopn.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
CfxopnVO req = new CfxopnVO();
// 参数设置
ResponseSet<CfxopnVO> response = cfxopn.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/CsndtlServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.CsndtlVO;
public class CsndtlServiceTest extends BaseTest{
@Autowired
private CsndtlService csndtl;
@Test
public void initTest() throws IOException {
CsndtlVO req = null;
File file = Paths.get(testJsonDir, "csndtl").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<CsndtlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<CsndtlVO> response = csndtl.init(req);
}
@Test
public void checkAllTest() throws IOException {
CsndtlVO req = null;
File file = Paths.get(testJsonDir, "csndtl").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<CsndtlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<CsndtlVO> response = csndtl.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
CsndtlVO req = null;
File file = Paths.get(testJsonDir, "csndtl").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<CsndtlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<CsndtlVO> response = csndtl.saveData(req);
}
@Test
public void pendingTest() throws IOException {
CsndtlVO req = null;
File file = Paths.get(testJsonDir, "csndtl").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<CsndtlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<CsndtlVO> response = csndtl.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
CsndtlVO req = new CsndtlVO();
// 参数设置
ResponseSet<CsndtlVO> response = csndtl.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/CsnselServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.CsnselVO;
public class CsnselServiceTest extends BaseTest{
@Autowired
private CsnselService csnsel;
@Test
public void initTest() throws IOException {
CsnselVO req = null;
File file = Paths.get(testJsonDir, "csnsel").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<CsnselVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<CsnselVO> response = csnsel.init(req);
}
@Test
public void checkAllTest() throws IOException {
CsnselVO req = null;
File file = Paths.get(testJsonDir, "csnsel").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<CsnselVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<CsnselVO> response = csnsel.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
CsnselVO req = null;
File file = Paths.get(testJsonDir, "csnsel").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<CsnselVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<CsnselVO> response = csnsel.saveData(req);
}
@Test
public void pendingTest() throws IOException {
CsnselVO req = null;
File file = Paths.get(testJsonDir, "csnsel").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<CsnselVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<CsnselVO> response = csnsel.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
CsnselVO req = new CsnselVO();
// 参数设置
ResponseSet<CsnselVO> response = csnsel.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbabrcServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbabrcVO;
public class DbabrcServiceTest extends BaseTest{
@Autowired
private DbabrcService dbabrc;
@Test
public void initTest() throws IOException {
DbabrcVO req = null;
File file = Paths.get(testJsonDir, "dbabrc").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbabrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbabrcVO> response = dbabrc.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbabrcVO req = null;
File file = Paths.get(testJsonDir, "dbabrc").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbabrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbabrcVO> response = dbabrc.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbabrcVO req = null;
File file = Paths.get(testJsonDir, "dbabrc").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbabrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbabrcVO> response = dbabrc.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbabrcVO req = null;
File file = Paths.get(testJsonDir, "dbabrc").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbabrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbabrcVO> response = dbabrc.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbabrcVO req = new DbabrcVO();
// 参数设置
ResponseSet<DbabrcVO> response = dbabrc.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbaetgServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbaetgVO;
public class DbaetgServiceTest extends BaseTest{
@Autowired
private DbaetgService dbaetg;
@Test
public void initTest() throws IOException {
DbaetgVO req = null;
File file = Paths.get(testJsonDir, "dbaetg").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbaetgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbaetgVO> response = dbaetg.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbaetgVO req = null;
File file = Paths.get(testJsonDir, "dbaetg").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbaetgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbaetgVO> response = dbaetg.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbaetgVO req = null;
File file = Paths.get(testJsonDir, "dbaetg").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbaetgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbaetgVO> response = dbaetg.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbaetgVO req = null;
File file = Paths.get(testJsonDir, "dbaetg").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbaetgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbaetgVO> response = dbaetg.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbaetgVO req = new DbaetgVO();
// 参数设置
ResponseSet<DbaetgVO> response = dbaetg.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbaetyServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbaetyVO;
public class DbaetyServiceTest extends BaseTest{
@Autowired
private DbaetyService dbaety;
@Test
public void initTest() throws IOException {
DbaetyVO req = null;
File file = Paths.get(testJsonDir, "dbaety").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbaetyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbaetyVO> response = dbaety.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbaetyVO req = null;
File file = Paths.get(testJsonDir, "dbaety").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbaetyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbaetyVO> response = dbaety.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbaetyVO req = null;
File file = Paths.get(testJsonDir, "dbaety").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbaetyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbaetyVO> response = dbaety.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbaetyVO req = null;
File file = Paths.get(testJsonDir, "dbaety").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbaetyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbaetyVO> response = dbaety.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbaetyVO req = new DbaetyVO();
// 参数设置
ResponseSet<DbaetyVO> response = dbaety.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbajgxServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbajgxVO;
public class DbajgxServiceTest extends BaseTest{
@Autowired
private DbajgxService dbajgx;
@Test
public void initTest() throws IOException {
DbajgxVO req = null;
File file = Paths.get(testJsonDir, "dbajgx").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbajgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbajgxVO> response = dbajgx.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbajgxVO req = null;
File file = Paths.get(testJsonDir, "dbajgx").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbajgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbajgxVO> response = dbajgx.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbajgxVO req = null;
File file = Paths.get(testJsonDir, "dbajgx").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbajgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbajgxVO> response = dbajgx.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbajgxVO req = null;
File file = Paths.get(testJsonDir, "dbajgx").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbajgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbajgxVO> response = dbajgx.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbajgxVO req = new DbajgxVO();
// 参数设置
ResponseSet<DbajgxVO> response = dbajgx.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbarolServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbarolVO;
public class DbarolServiceTest extends BaseTest{
@Autowired
private DbarolService dbarol;
@Test
public void initTest() throws IOException {
DbarolVO req = null;
File file = Paths.get(testJsonDir, "dbarol").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbarolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbarolVO> response = dbarol.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbarolVO req = null;
File file = Paths.get(testJsonDir, "dbarol").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbarolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbarolVO> response = dbarol.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbarolVO req = null;
File file = Paths.get(testJsonDir, "dbarol").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbarolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbarolVO> response = dbarol.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbarolVO req = null;
File file = Paths.get(testJsonDir, "dbarol").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbarolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbarolVO> response = dbarol.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbarolVO req = new DbarolVO();
// 参数设置
ResponseSet<DbarolVO> response = dbarol.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbdbrcServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbdbrcVO;
public class DbdbrcServiceTest extends BaseTest{
@Autowired
private DbdbrcService dbdbrc;
@Test
public void initTest() throws IOException {
DbdbrcVO req = null;
File file = Paths.get(testJsonDir, "dbdbrc").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdbrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdbrcVO> response = dbdbrc.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbdbrcVO req = null;
File file = Paths.get(testJsonDir, "dbdbrc").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdbrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdbrcVO> response = dbdbrc.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbdbrcVO req = null;
File file = Paths.get(testJsonDir, "dbdbrc").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdbrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdbrcVO> response = dbdbrc.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbdbrcVO req = null;
File file = Paths.get(testJsonDir, "dbdbrc").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdbrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdbrcVO> response = dbdbrc.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbdbrcVO req = new DbdbrcVO();
// 参数设置
ResponseSet<DbdbrcVO> response = dbdbrc.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbdetgServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbdetgVO;
public class DbdetgServiceTest extends BaseTest{
@Autowired
private DbdetgService dbdetg;
@Test
public void initTest() throws IOException {
DbdetgVO req = null;
File file = Paths.get(testJsonDir, "dbdetg").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdetgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdetgVO> response = dbdetg.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbdetgVO req = null;
File file = Paths.get(testJsonDir, "dbdetg").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdetgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdetgVO> response = dbdetg.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbdetgVO req = null;
File file = Paths.get(testJsonDir, "dbdetg").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdetgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdetgVO> response = dbdetg.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbdetgVO req = null;
File file = Paths.get(testJsonDir, "dbdetg").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdetgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdetgVO> response = dbdetg.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbdetgVO req = new DbdetgVO();
// 参数设置
ResponseSet<DbdetgVO> response = dbdetg.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbdetyServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbdetyVO;
public class DbdetyServiceTest extends BaseTest{
@Autowired
private DbdetyService dbdety;
@Test
public void initTest() throws IOException {
DbdetyVO req = null;
File file = Paths.get(testJsonDir, "dbdety").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdetyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdetyVO> response = dbdety.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbdetyVO req = null;
File file = Paths.get(testJsonDir, "dbdety").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdetyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdetyVO> response = dbdety.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbdetyVO req = null;
File file = Paths.get(testJsonDir, "dbdety").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdetyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdetyVO> response = dbdety.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbdetyVO req = null;
File file = Paths.get(testJsonDir, "dbdety").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdetyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdetyVO> response = dbdety.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbdetyVO req = new DbdetyVO();
// 参数设置
ResponseSet<DbdetyVO> response = dbdety.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbdjgxServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbdjgxVO;
public class DbdjgxServiceTest extends BaseTest{
@Autowired
private DbdjgxService dbdjgx;
@Test
public void initTest() throws IOException {
DbdjgxVO req = null;
File file = Paths.get(testJsonDir, "dbdjgx").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdjgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdjgxVO> response = dbdjgx.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbdjgxVO req = null;
File file = Paths.get(testJsonDir, "dbdjgx").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdjgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdjgxVO> response = dbdjgx.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbdjgxVO req = null;
File file = Paths.get(testJsonDir, "dbdjgx").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdjgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdjgxVO> response = dbdjgx.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbdjgxVO req = null;
File file = Paths.get(testJsonDir, "dbdjgx").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdjgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdjgxVO> response = dbdjgx.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbdjgxVO req = new DbdjgxVO();
// 参数设置
ResponseSet<DbdjgxVO> response = dbdjgx.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbdrolServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbdrolVO;
public class DbdrolServiceTest extends BaseTest{
@Autowired
private DbdrolService dbdrol;
@Test
public void initTest() throws IOException {
DbdrolVO req = null;
File file = Paths.get(testJsonDir, "dbdrol").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdrolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdrolVO> response = dbdrol.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbdrolVO req = null;
File file = Paths.get(testJsonDir, "dbdrol").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdrolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdrolVO> response = dbdrol.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbdrolVO req = null;
File file = Paths.get(testJsonDir, "dbdrol").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdrolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdrolVO> response = dbdrol.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbdrolVO req = null;
File file = Paths.get(testJsonDir, "dbdrol").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbdrolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbdrolVO> response = dbdrol.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbdrolVO req = new DbdrolVO();
// 参数设置
ResponseSet<DbdrolVO> response = dbdrol.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbebrcServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbebrcVO;
public class DbebrcServiceTest extends BaseTest{
@Autowired
private DbebrcService dbebrc;
@Test
public void initTest() throws IOException {
DbebrcVO req = null;
File file = Paths.get(testJsonDir, "dbebrc").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbebrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbebrcVO> response = dbebrc.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbebrcVO req = null;
File file = Paths.get(testJsonDir, "dbebrc").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbebrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbebrcVO> response = dbebrc.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbebrcVO req = null;
File file = Paths.get(testJsonDir, "dbebrc").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbebrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbebrcVO> response = dbebrc.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbebrcVO req = null;
File file = Paths.get(testJsonDir, "dbebrc").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbebrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbebrcVO> response = dbebrc.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbebrcVO req = new DbebrcVO();
// 参数设置
ResponseSet<DbebrcVO> response = dbebrc.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbeetgServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbeetgVO;
public class DbeetgServiceTest extends BaseTest{
@Autowired
private DbeetgService dbeetg;
@Test
public void initTest() throws IOException {
DbeetgVO req = null;
File file = Paths.get(testJsonDir, "dbeetg").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbeetgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbeetgVO> response = dbeetg.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbeetgVO req = null;
File file = Paths.get(testJsonDir, "dbeetg").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbeetgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbeetgVO> response = dbeetg.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbeetgVO req = null;
File file = Paths.get(testJsonDir, "dbeetg").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbeetgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbeetgVO> response = dbeetg.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbeetgVO req = null;
File file = Paths.get(testJsonDir, "dbeetg").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbeetgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbeetgVO> response = dbeetg.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbeetgVO req = new DbeetgVO();
// 参数设置
ResponseSet<DbeetgVO> response = dbeetg.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbeetyServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbeetyVO;
public class DbeetyServiceTest extends BaseTest{
@Autowired
private DbeetyService dbeety;
@Test
public void initTest() throws IOException {
DbeetyVO req = null;
File file = Paths.get(testJsonDir, "dbeety").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbeetyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbeetyVO> response = dbeety.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbeetyVO req = null;
File file = Paths.get(testJsonDir, "dbeety").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbeetyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbeetyVO> response = dbeety.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbeetyVO req = null;
File file = Paths.get(testJsonDir, "dbeety").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbeetyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbeetyVO> response = dbeety.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbeetyVO req = null;
File file = Paths.get(testJsonDir, "dbeety").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbeetyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbeetyVO> response = dbeety.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbeetyVO req = new DbeetyVO();
// 参数设置
ResponseSet<DbeetyVO> response = dbeety.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbefrrServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbefrrVO;
public class DbefrrServiceTest extends BaseTest{
@Autowired
private DbefrrService dbefrr;
@Test
public void initTest() throws IOException {
DbefrrVO req = null;
File file = Paths.get(testJsonDir, "dbefrr").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbefrrVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbefrrVO> response = dbefrr.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbefrrVO req = null;
File file = Paths.get(testJsonDir, "dbefrr").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbefrrVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbefrrVO> response = dbefrr.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbefrrVO req = null;
File file = Paths.get(testJsonDir, "dbefrr").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbefrrVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbefrrVO> response = dbefrr.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbefrrVO req = null;
File file = Paths.get(testJsonDir, "dbefrr").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbefrrVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbefrrVO> response = dbefrr.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbefrrVO req = new DbefrrVO();
// 参数设置
ResponseSet<DbefrrVO> response = dbefrr.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbejgxServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbejgxVO;
public class DbejgxServiceTest extends BaseTest{
@Autowired
private DbejgxService dbejgx;
@Test
public void initTest() throws IOException {
DbejgxVO req = null;
File file = Paths.get(testJsonDir, "dbejgx").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbejgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbejgxVO> response = dbejgx.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbejgxVO req = null;
File file = Paths.get(testJsonDir, "dbejgx").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbejgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbejgxVO> response = dbejgx.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbejgxVO req = null;
File file = Paths.get(testJsonDir, "dbejgx").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbejgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbejgxVO> response = dbejgx.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbejgxVO req = null;
File file = Paths.get(testJsonDir, "dbejgx").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbejgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbejgxVO> response = dbejgx.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbejgxVO req = new DbejgxVO();
// 参数设置
ResponseSet<DbejgxVO> response = dbejgx.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DberolServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DberolVO;
public class DberolServiceTest extends BaseTest{
@Autowired
private DberolService dberol;
@Test
public void initTest() throws IOException {
DberolVO req = null;
File file = Paths.get(testJsonDir, "dberol").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DberolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DberolVO> response = dberol.init(req);
}
@Test
public void checkAllTest() throws IOException {
DberolVO req = null;
File file = Paths.get(testJsonDir, "dberol").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DberolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DberolVO> response = dberol.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DberolVO req = null;
File file = Paths.get(testJsonDir, "dberol").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DberolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DberolVO> response = dberol.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DberolVO req = null;
File file = Paths.get(testJsonDir, "dberol").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DberolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DberolVO> response = dberol.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DberolVO req = new DberolVO();
// 参数设置
ResponseSet<DberolVO> response = dberol.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbesrlServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbesrlVO;
public class DbesrlServiceTest extends BaseTest{
@Autowired
private DbesrlService dbesrl;
@Test
public void initTest() throws IOException {
DbesrlVO req = null;
File file = Paths.get(testJsonDir, "dbesrl").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbesrlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbesrlVO> response = dbesrl.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbesrlVO req = null;
File file = Paths.get(testJsonDir, "dbesrl").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbesrlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbesrlVO> response = dbesrl.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbesrlVO req = null;
File file = Paths.get(testJsonDir, "dbesrl").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbesrlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbesrlVO> response = dbesrl.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbesrlVO req = null;
File file = Paths.get(testJsonDir, "dbesrl").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbesrlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbesrlVO> response = dbesrl.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbesrlVO req = new DbesrlVO();
// 参数设置
ResponseSet<DbesrlVO> response = dbesrl.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbetelServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbetelVO;
public class DbetelServiceTest extends BaseTest{
@Autowired
private DbetelService dbetel;
@Test
public void initTest() throws IOException {
DbetelVO req = null;
File file = Paths.get(testJsonDir, "dbetel").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbetelVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbetelVO> response = dbetel.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbetelVO req = null;
File file = Paths.get(testJsonDir, "dbetel").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbetelVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbetelVO> response = dbetel.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbetelVO req = null;
File file = Paths.get(testJsonDir, "dbetel").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbetelVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbetelVO> response = dbetel.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbetelVO req = null;
File file = Paths.get(testJsonDir, "dbetel").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbetelVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbetelVO> response = dbetel.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbetelVO req = new DbetelVO();
// 参数设置
ResponseSet<DbetelVO> response = dbetel.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbibrcServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbibrcVO;
public class DbibrcServiceTest extends BaseTest{
@Autowired
private DbibrcService dbibrc;
@Test
public void initTest() throws IOException {
DbibrcVO req = null;
File file = Paths.get(testJsonDir, "dbibrc").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbibrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbibrcVO> response = dbibrc.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbibrcVO req = null;
File file = Paths.get(testJsonDir, "dbibrc").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbibrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbibrcVO> response = dbibrc.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbibrcVO req = null;
File file = Paths.get(testJsonDir, "dbibrc").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbibrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbibrcVO> response = dbibrc.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbibrcVO req = null;
File file = Paths.get(testJsonDir, "dbibrc").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbibrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbibrcVO> response = dbibrc.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbibrcVO req = new DbibrcVO();
// 参数设置
ResponseSet<DbibrcVO> response = dbibrc.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbietgServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbietgVO;
public class DbietgServiceTest extends BaseTest{
@Autowired
private DbietgService dbietg;
@Test
public void initTest() throws IOException {
DbietgVO req = null;
File file = Paths.get(testJsonDir, "dbietg").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbietgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbietgVO> response = dbietg.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbietgVO req = null;
File file = Paths.get(testJsonDir, "dbietg").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbietgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbietgVO> response = dbietg.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbietgVO req = null;
File file = Paths.get(testJsonDir, "dbietg").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbietgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbietgVO> response = dbietg.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbietgVO req = null;
File file = Paths.get(testJsonDir, "dbietg").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbietgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbietgVO> response = dbietg.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbietgVO req = new DbietgVO();
// 参数设置
ResponseSet<DbietgVO> response = dbietg.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbietyServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbietyVO;
public class DbietyServiceTest extends BaseTest{
@Autowired
private DbietyService dbiety;
@Test
public void initTest() throws IOException {
DbietyVO req = null;
File file = Paths.get(testJsonDir, "dbiety").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbietyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbietyVO> response = dbiety.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbietyVO req = null;
File file = Paths.get(testJsonDir, "dbiety").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbietyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbietyVO> response = dbiety.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbietyVO req = null;
File file = Paths.get(testJsonDir, "dbiety").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbietyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbietyVO> response = dbiety.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbietyVO req = null;
File file = Paths.get(testJsonDir, "dbiety").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbietyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbietyVO> response = dbiety.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbietyVO req = new DbietyVO();
// 参数设置
ResponseSet<DbietyVO> response = dbiety.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbifrrServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbifrrVO;
public class DbifrrServiceTest extends BaseTest{
@Autowired
private DbifrrService dbifrr;
@Test
public void initTest() throws IOException {
DbifrrVO req = null;
File file = Paths.get(testJsonDir, "dbifrr").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbifrrVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbifrrVO> response = dbifrr.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbifrrVO req = null;
File file = Paths.get(testJsonDir, "dbifrr").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbifrrVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbifrrVO> response = dbifrr.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbifrrVO req = null;
File file = Paths.get(testJsonDir, "dbifrr").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbifrrVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbifrrVO> response = dbifrr.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbifrrVO req = null;
File file = Paths.get(testJsonDir, "dbifrr").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbifrrVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbifrrVO> response = dbifrr.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbifrrVO req = new DbifrrVO();
// 参数设置
ResponseSet<DbifrrVO> response = dbifrr.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbijgxServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbijgxVO;
public class DbijgxServiceTest extends BaseTest{
@Autowired
private DbijgxService dbijgx;
@Test
public void initTest() throws IOException {
DbijgxVO req = null;
File file = Paths.get(testJsonDir, "dbijgx").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbijgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbijgxVO> response = dbijgx.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbijgxVO req = null;
File file = Paths.get(testJsonDir, "dbijgx").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbijgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbijgxVO> response = dbijgx.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbijgxVO req = null;
File file = Paths.get(testJsonDir, "dbijgx").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbijgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbijgxVO> response = dbijgx.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbijgxVO req = null;
File file = Paths.get(testJsonDir, "dbijgx").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbijgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbijgxVO> response = dbijgx.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbijgxVO req = new DbijgxVO();
// 参数设置
ResponseSet<DbijgxVO> response = dbijgx.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbirolServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbirolVO;
public class DbirolServiceTest extends BaseTest{
@Autowired
private DbirolService dbirol;
@Test
public void initTest() throws IOException {
DbirolVO req = null;
File file = Paths.get(testJsonDir, "dbirol").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbirolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbirolVO> response = dbirol.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbirolVO req = null;
File file = Paths.get(testJsonDir, "dbirol").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbirolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbirolVO> response = dbirol.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbirolVO req = null;
File file = Paths.get(testJsonDir, "dbirol").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbirolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbirolVO> response = dbirol.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbirolVO req = null;
File file = Paths.get(testJsonDir, "dbirol").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbirolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbirolVO> response = dbirol.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbirolVO req = new DbirolVO();
// 参数设置
ResponseSet<DbirolVO> response = dbirol.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbisrlServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbisrlVO;
public class DbisrlServiceTest extends BaseTest{
@Autowired
private DbisrlService dbisrl;
@Test
public void initTest() throws IOException {
DbisrlVO req = null;
File file = Paths.get(testJsonDir, "dbisrl").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbisrlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbisrlVO> response = dbisrl.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbisrlVO req = null;
File file = Paths.get(testJsonDir, "dbisrl").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbisrlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbisrlVO> response = dbisrl.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbisrlVO req = null;
File file = Paths.get(testJsonDir, "dbisrl").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbisrlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbisrlVO> response = dbisrl.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbisrlVO req = null;
File file = Paths.get(testJsonDir, "dbisrl").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbisrlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbisrlVO> response = dbisrl.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbisrlVO req = new DbisrlVO();
// 参数设置
ResponseSet<DbisrlVO> response = dbisrl.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbitelServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbitelVO;
public class DbitelServiceTest extends BaseTest{
@Autowired
private DbitelService dbitel;
@Test
public void initTest() throws IOException {
DbitelVO req = null;
File file = Paths.get(testJsonDir, "dbitel").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbitelVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbitelVO> response = dbitel.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbitelVO req = null;
File file = Paths.get(testJsonDir, "dbitel").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbitelVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbitelVO> response = dbitel.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbitelVO req = null;
File file = Paths.get(testJsonDir, "dbitel").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbitelVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbitelVO> response = dbitel.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbitelVO req = null;
File file = Paths.get(testJsonDir, "dbitel").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbitelVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbitelVO> response = dbitel.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbitelVO req = new DbitelVO();
// 参数设置
ResponseSet<DbitelVO> response = dbitel.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DblbrcServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DblbrcVO;
public class DblbrcServiceTest extends BaseTest{
@Autowired
private DblbrcService dblbrc;
@Test
public void initTest() throws IOException {
DblbrcVO req = null;
File file = Paths.get(testJsonDir, "dblbrc").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DblbrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DblbrcVO> response = dblbrc.init(req);
}
@Test
public void checkAllTest() throws IOException {
DblbrcVO req = null;
File file = Paths.get(testJsonDir, "dblbrc").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DblbrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DblbrcVO> response = dblbrc.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DblbrcVO req = null;
File file = Paths.get(testJsonDir, "dblbrc").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DblbrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DblbrcVO> response = dblbrc.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DblbrcVO req = null;
File file = Paths.get(testJsonDir, "dblbrc").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DblbrcVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DblbrcVO> response = dblbrc.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DblbrcVO req = new DblbrcVO();
// 参数设置
ResponseSet<DblbrcVO> response = dblbrc.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbletgServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbletgVO;
public class DbletgServiceTest extends BaseTest{
@Autowired
private DbletgService dbletg;
@Test
public void initTest() throws IOException {
DbletgVO req = null;
File file = Paths.get(testJsonDir, "dbletg").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbletgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbletgVO> response = dbletg.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbletgVO req = null;
File file = Paths.get(testJsonDir, "dbletg").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbletgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbletgVO> response = dbletg.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbletgVO req = null;
File file = Paths.get(testJsonDir, "dbletg").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbletgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbletgVO> response = dbletg.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbletgVO req = null;
File file = Paths.get(testJsonDir, "dbletg").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbletgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbletgVO> response = dbletg.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbletgVO req = new DbletgVO();
// 参数设置
ResponseSet<DbletgVO> response = dbletg.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbletyServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbletyVO;
public class DbletyServiceTest extends BaseTest{
@Autowired
private DbletyService dblety;
@Test
public void initTest() throws IOException {
DbletyVO req = null;
File file = Paths.get(testJsonDir, "dblety").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbletyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbletyVO> response = dblety.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbletyVO req = null;
File file = Paths.get(testJsonDir, "dblety").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbletyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbletyVO> response = dblety.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbletyVO req = null;
File file = Paths.get(testJsonDir, "dblety").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbletyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbletyVO> response = dblety.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbletyVO req = null;
File file = Paths.get(testJsonDir, "dblety").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbletyVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbletyVO> response = dblety.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbletyVO req = new DbletyVO();
// 参数设置
ResponseSet<DbletyVO> response = dblety.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbljgxServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbljgxVO;
public class DbljgxServiceTest extends BaseTest{
@Autowired
private DbljgxService dbljgx;
@Test
public void initTest() throws IOException {
DbljgxVO req = null;
File file = Paths.get(testJsonDir, "dbljgx").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbljgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbljgxVO> response = dbljgx.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbljgxVO req = null;
File file = Paths.get(testJsonDir, "dbljgx").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbljgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbljgxVO> response = dbljgx.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbljgxVO req = null;
File file = Paths.get(testJsonDir, "dbljgx").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbljgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbljgxVO> response = dbljgx.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbljgxVO req = null;
File file = Paths.get(testJsonDir, "dbljgx").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbljgxVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbljgxVO> response = dbljgx.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbljgxVO req = new DbljgxVO();
// 参数设置
ResponseSet<DbljgxVO> response = dbljgx.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DblrolServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DblrolVO;
public class DblrolServiceTest extends BaseTest{
@Autowired
private DblrolService dblrol;
@Test
public void initTest() throws IOException {
DblrolVO req = null;
File file = Paths.get(testJsonDir, "dblrol").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DblrolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DblrolVO> response = dblrol.init(req);
}
@Test
public void checkAllTest() throws IOException {
DblrolVO req = null;
File file = Paths.get(testJsonDir, "dblrol").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DblrolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DblrolVO> response = dblrol.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DblrolVO req = null;
File file = Paths.get(testJsonDir, "dblrol").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DblrolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DblrolVO> response = dblrol.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DblrolVO req = null;
File file = Paths.get(testJsonDir, "dblrol").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DblrolVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DblrolVO> response = dblrol.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DblrolVO req = new DblrolVO();
// 参数设置
ResponseSet<DblrolVO> response = dblrol.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DblsrlServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DblsrlVO;
public class DblsrlServiceTest extends BaseTest{
@Autowired
private DblsrlService dblsrl;
@Test
public void initTest() throws IOException {
DblsrlVO req = null;
File file = Paths.get(testJsonDir, "dblsrl").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DblsrlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DblsrlVO> response = dblsrl.init(req);
}
@Test
public void checkAllTest() throws IOException {
DblsrlVO req = null;
File file = Paths.get(testJsonDir, "dblsrl").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DblsrlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DblsrlVO> response = dblsrl.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DblsrlVO req = null;
File file = Paths.get(testJsonDir, "dblsrl").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DblsrlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DblsrlVO> response = dblsrl.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DblsrlVO req = null;
File file = Paths.get(testJsonDir, "dblsrl").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DblsrlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DblsrlVO> response = dblsrl.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DblsrlVO req = new DblsrlVO();
// 参数设置
ResponseSet<DblsrlVO> response = dblsrl.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbltelServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbltelVO;
public class DbltelServiceTest extends BaseTest{
@Autowired
private DbltelService dbltel;
@Test
public void initTest() throws IOException {
DbltelVO req = null;
File file = Paths.get(testJsonDir, "dbltel").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbltelVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbltelVO> response = dbltel.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbltelVO req = null;
File file = Paths.get(testJsonDir, "dbltel").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbltelVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbltelVO> response = dbltel.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbltelVO req = null;
File file = Paths.get(testJsonDir, "dbltel").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbltelVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbltelVO> response = dbltel.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbltelVO req = null;
File file = Paths.get(testJsonDir, "dbltel").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbltelVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbltelVO> response = dbltel.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbltelVO req = new DbltelVO();
// 参数设置
ResponseSet<DbltelVO> response = dbltel.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/DbpusrServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.DbpusrVO;
public class DbpusrServiceTest extends BaseTest{
@Autowired
private DbpusrService dbpusr;
@Test
public void initTest() throws IOException {
DbpusrVO req = null;
File file = Paths.get(testJsonDir, "dbpusr").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbpusrVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbpusrVO> response = dbpusr.init(req);
}
@Test
public void checkAllTest() throws IOException {
DbpusrVO req = null;
File file = Paths.get(testJsonDir, "dbpusr").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbpusrVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbpusrVO> response = dbpusr.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
DbpusrVO req = null;
File file = Paths.get(testJsonDir, "dbpusr").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbpusrVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbpusrVO> response = dbpusr.saveData(req);
}
@Test
public void pendingTest() throws IOException {
DbpusrVO req = null;
File file = Paths.get(testJsonDir, "dbpusr").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<DbpusrVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<DbpusrVO> response = dbpusr.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
DbpusrVO req = new DbpusrVO();
// 参数设置
ResponseSet<DbpusrVO> response = dbpusr.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/FmtdtlServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.FmtdtlVO;
public class FmtdtlServiceTest extends BaseTest{
@Autowired
private FmtdtlService fmtdtl;
@Test
public void initTest() throws IOException {
FmtdtlVO req = null;
File file = Paths.get(testJsonDir, "fmtdtl").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<FmtdtlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<FmtdtlVO> response = fmtdtl.init(req);
}
@Test
public void checkAllTest() throws IOException {
FmtdtlVO req = null;
File file = Paths.get(testJsonDir, "fmtdtl").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<FmtdtlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<FmtdtlVO> response = fmtdtl.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
FmtdtlVO req = null;
File file = Paths.get(testJsonDir, "fmtdtl").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<FmtdtlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<FmtdtlVO> response = fmtdtl.saveData(req);
}
@Test
public void pendingTest() throws IOException {
FmtdtlVO req = null;
File file = Paths.get(testJsonDir, "fmtdtl").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<FmtdtlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<FmtdtlVO> response = fmtdtl.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
FmtdtlVO req = new FmtdtlVO();
// 参数设置
ResponseSet<FmtdtlVO> response = fmtdtl.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/FmtselServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.FmtselVO;
public class FmtselServiceTest extends BaseTest{
@Autowired
private FmtselService fmtsel;
@Test
public void initTest() throws IOException {
FmtselVO req = null;
File file = Paths.get(testJsonDir, "fmtsel").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<FmtselVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<FmtselVO> response = fmtsel.init(req);
}
@Test
public void checkAllTest() throws IOException {
FmtselVO req = null;
File file = Paths.get(testJsonDir, "fmtsel").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<FmtselVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<FmtselVO> response = fmtsel.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
FmtselVO req = null;
File file = Paths.get(testJsonDir, "fmtsel").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<FmtselVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<FmtselVO> response = fmtsel.saveData(req);
}
@Test
public void pendingTest() throws IOException {
FmtselVO req = null;
File file = Paths.get(testJsonDir, "fmtsel").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<FmtselVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<FmtselVO> response = fmtsel.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
FmtselVO req = new FmtselVO();
// 参数设置
ResponseSet<FmtselVO> response = fmtsel.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/MsgdtlServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.MsgdtlVO;
public class MsgdtlServiceTest extends BaseTest{
@Autowired
private MsgdtlService msgdtl;
@Test
public void initTest() throws IOException {
MsgdtlVO req = null;
File file = Paths.get(testJsonDir, "msgdtl").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<MsgdtlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<MsgdtlVO> response = msgdtl.init(req);
}
@Test
public void checkAllTest() throws IOException {
MsgdtlVO req = null;
File file = Paths.get(testJsonDir, "msgdtl").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<MsgdtlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<MsgdtlVO> response = msgdtl.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
MsgdtlVO req = null;
File file = Paths.get(testJsonDir, "msgdtl").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<MsgdtlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<MsgdtlVO> response = msgdtl.saveData(req);
}
@Test
public void pendingTest() throws IOException {
MsgdtlVO req = null;
File file = Paths.get(testJsonDir, "msgdtl").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<MsgdtlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<MsgdtlVO> response = msgdtl.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
MsgdtlVO req = new MsgdtlVO();
// 参数设置
ResponseSet<MsgdtlVO> response = msgdtl.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/OfficeServiceTest.java
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.ceb.gjjs.mda.service.OfficeService;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
......
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/PbtaddServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.PbtaddVO;
public class PbtaddServiceTest extends BaseTest{
@Autowired
private PbtaddService pbtadd;
@Test
public void initTest() throws IOException {
PbtaddVO req = null;
File file = Paths.get(testJsonDir, "pbtadd").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<PbtaddVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<PbtaddVO> response = pbtadd.init(req);
}
@Test
public void checkAllTest() throws IOException {
PbtaddVO req = null;
File file = Paths.get(testJsonDir, "pbtadd").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<PbtaddVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<PbtaddVO> response = pbtadd.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
PbtaddVO req = null;
File file = Paths.get(testJsonDir, "pbtadd").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<PbtaddVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<PbtaddVO> response = pbtadd.saveData(req);
}
@Test
public void pendingTest() throws IOException {
PbtaddVO req = null;
File file = Paths.get(testJsonDir, "pbtadd").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<PbtaddVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<PbtaddVO> response = pbtadd.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
PbtaddVO req = new PbtaddVO();
// 参数设置
ResponseSet<PbtaddVO> response = pbtadd.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/PbtameServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.PbtameVO;
public class PbtameServiceTest extends BaseTest{
@Autowired
private PbtameService pbtame;
@Test
public void initTest() throws IOException {
PbtameVO req = null;
File file = Paths.get(testJsonDir, "pbtame").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<PbtameVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<PbtameVO> response = pbtame.init(req);
}
@Test
public void checkAllTest() throws IOException {
PbtameVO req = null;
File file = Paths.get(testJsonDir, "pbtame").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<PbtameVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<PbtameVO> response = pbtame.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
PbtameVO req = null;
File file = Paths.get(testJsonDir, "pbtame").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<PbtameVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<PbtameVO> response = pbtame.saveData(req);
}
@Test
public void pendingTest() throws IOException {
PbtameVO req = null;
File file = Paths.get(testJsonDir, "pbtame").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<PbtameVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<PbtameVO> response = pbtame.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
PbtameVO req = new PbtameVO();
// 参数设置
ResponseSet<PbtameVO> response = pbtame.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/PbtdtlServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.PbtdtlVO;
public class PbtdtlServiceTest extends BaseTest{
@Autowired
private PbtdtlService pbtdtl;
@Test
public void initTest() throws IOException {
PbtdtlVO req = null;
File file = Paths.get(testJsonDir, "pbtdtl").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<PbtdtlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<PbtdtlVO> response = pbtdtl.init(req);
}
@Test
public void checkAllTest() throws IOException {
PbtdtlVO req = null;
File file = Paths.get(testJsonDir, "pbtdtl").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<PbtdtlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<PbtdtlVO> response = pbtdtl.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
PbtdtlVO req = null;
File file = Paths.get(testJsonDir, "pbtdtl").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<PbtdtlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<PbtdtlVO> response = pbtdtl.saveData(req);
}
@Test
public void pendingTest() throws IOException {
PbtdtlVO req = null;
File file = Paths.get(testJsonDir, "pbtdtl").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<PbtdtlVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<PbtdtlVO> response = pbtdtl.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
PbtdtlVO req = new PbtdtlVO();
// 参数设置
ResponseSet<PbtdtlVO> response = pbtdtl.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/PbtselServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.PbtselVO;
public class PbtselServiceTest extends BaseTest{
@Autowired
private PbtselService pbtsel;
@Test
public void initTest() throws IOException {
PbtselVO req = null;
File file = Paths.get(testJsonDir, "pbtsel").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<PbtselVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<PbtselVO> response = pbtsel.init(req);
}
@Test
public void checkAllTest() throws IOException {
PbtselVO req = null;
File file = Paths.get(testJsonDir, "pbtsel").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<PbtselVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<PbtselVO> response = pbtsel.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
PbtselVO req = null;
File file = Paths.get(testJsonDir, "pbtsel").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<PbtselVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<PbtselVO> response = pbtsel.saveData(req);
}
@Test
public void pendingTest() throws IOException {
PbtselVO req = null;
File file = Paths.get(testJsonDir, "pbtsel").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<PbtselVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<PbtselVO> response = pbtsel.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
PbtselVO req = new PbtselVO();
// 参数设置
ResponseSet<PbtselVO> response = pbtsel.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/RcvselServiceTest.java
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.ceb.gjjs.mda.service.RcvselService;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
......
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/RectskServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.RectskVO;
public class RectskServiceTest extends BaseTest{
@Autowired
private RectskService rectsk;
@Test
public void initTest() throws IOException {
RectskVO req = null;
File file = Paths.get(testJsonDir, "rectsk").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<RectskVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<RectskVO> response = rectsk.init(req);
}
@Test
public void checkAllTest() throws IOException {
RectskVO req = null;
File file = Paths.get(testJsonDir, "rectsk").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<RectskVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<RectskVO> response = rectsk.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
RectskVO req = null;
File file = Paths.get(testJsonDir, "rectsk").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<RectskVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<RectskVO> response = rectsk.saveData(req);
}
@Test
public void pendingTest() throws IOException {
RectskVO req = null;
File file = Paths.get(testJsonDir, "rectsk").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<RectskVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<RectskVO> response = rectsk.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
RectskVO req = new RectskVO();
// 参数设置
ResponseSet<RectskVO> response = rectsk.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/RxxtskServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.RxxtskVO;
public class RxxtskServiceTest extends BaseTest{
@Autowired
private RxxtskService rxxtsk;
@Test
public void initTest() throws IOException {
RxxtskVO req = null;
File file = Paths.get(testJsonDir, "rxxtsk").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<RxxtskVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<RxxtskVO> response = rxxtsk.init(req);
}
@Test
public void checkAllTest() throws IOException {
RxxtskVO req = null;
File file = Paths.get(testJsonDir, "rxxtsk").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<RxxtskVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<RxxtskVO> response = rxxtsk.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
RxxtskVO req = null;
File file = Paths.get(testJsonDir, "rxxtsk").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<RxxtskVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<RxxtskVO> response = rxxtsk.saveData(req);
}
@Test
public void pendingTest() throws IOException {
RxxtskVO req = null;
File file = Paths.get(testJsonDir, "rxxtsk").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<RxxtskVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<RxxtskVO> response = rxxtsk.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
RxxtskVO req = new RxxtskVO();
// 参数设置
ResponseSet<RxxtskVO> response = rxxtsk.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/SndselServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.SndselVO;
public class SndselServiceTest extends BaseTest{
@Autowired
private SndselService sndsel;
@Test
public void initTest() throws IOException {
SndselVO req = null;
File file = Paths.get(testJsonDir, "sndsel").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<SndselVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<SndselVO> response = sndsel.init(req);
}
@Test
public void checkAllTest() throws IOException {
SndselVO req = null;
File file = Paths.get(testJsonDir, "sndsel").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<SndselVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<SndselVO> response = sndsel.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
SndselVO req = null;
File file = Paths.get(testJsonDir, "sndsel").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<SndselVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<SndselVO> response = sndsel.saveData(req);
}
@Test
public void pendingTest() throws IOException {
SndselVO req = null;
File file = Paths.get(testJsonDir, "sndsel").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<SndselVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<SndselVO> response = sndsel.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
SndselVO req = new SndselVO();
// 参数设置
ResponseSet<SndselVO> response = sndsel.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/SndtskServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.SndtskVO;
public class SndtskServiceTest extends BaseTest{
@Autowired
private SndtskService sndtsk;
@Test
public void initTest() throws IOException {
SndtskVO req = null;
File file = Paths.get(testJsonDir, "sndtsk").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<SndtskVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<SndtskVO> response = sndtsk.init(req);
}
@Test
public void checkAllTest() throws IOException {
SndtskVO req = null;
File file = Paths.get(testJsonDir, "sndtsk").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<SndtskVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<SndtskVO> response = sndtsk.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
SndtskVO req = null;
File file = Paths.get(testJsonDir, "sndtsk").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<SndtskVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<SndtskVO> response = sndtsk.saveData(req);
}
@Test
public void pendingTest() throws IOException {
SndtskVO req = null;
File file = Paths.get(testJsonDir, "sndtsk").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<SndtskVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<SndtskVO> response = sndtsk.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
SndtskVO req = new SndtskVO();
// 参数设置
ResponseSet<SndtskVO> response = sndtsk.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/UsrmsgServiceTest.java deleted 100644 → 0
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ceb.gjjs.mda.vo.UsrmsgVO;
public class UsrmsgServiceTest extends BaseTest{
@Autowired
private UsrmsgService usrmsg;
@Test
public void initTest() throws IOException {
UsrmsgVO req = null;
File file = Paths.get(testJsonDir, "usrmsg").resolve("init.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<UsrmsgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<UsrmsgVO> response = usrmsg.init(req);
}
@Test
public void checkAllTest() throws IOException {
UsrmsgVO req = null;
File file = Paths.get(testJsonDir, "usrmsg").resolve("checkAll.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<UsrmsgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<UsrmsgVO> response = usrmsg.checkAll(req);
}
@Test
public void saveDataTest() throws IOException {
UsrmsgVO req = null;
File file = Paths.get(testJsonDir, "usrmsg").resolve("saveData.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<UsrmsgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<UsrmsgVO> response = usrmsg.saveData(req);
}
@Test
public void pendingTest() throws IOException {
UsrmsgVO req = null;
File file = Paths.get(testJsonDir, "usrmsg").resolve("pending.json").toFile();
if (file.exists()) {
req = om.readValue(file, new TypeReference<UsrmsgVO>() { });
}
Assert.notNull(req, "调用参数不能为空！");
ResponseSet<UsrmsgVO> response = usrmsg.pending(req);
}
@Test
public void executeDefault() {
String rule = "";
UsrmsgVO req = new UsrmsgVO();
// 参数设置
ResponseSet<UsrmsgVO> response = usrmsg.executeDefault(req,rule);
}
}
gjjs-bd-business/src/test/java/com/ceb/gjjs/mda/junitTest/XxxtskServiceTest.java
package com.ceb.gjjs.mda.junitTest;
import com.brilliance.mda.runtime.response.ResponseSet;
import com.ceb.gjjs.mda.service.XxxtskService;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
......
lib/tools.jar 0 → 100644
File added
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment