You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@linkis.apache.org by pe...@apache.org on 2022/03/09 09:16:42 UTC
[incubator-linkis] 04/06: add spotless format for unit test
This is an automated email from the ASF dual-hosted git repository.
peacewong pushed a commit to branch dev-1.1.0-datasource
in repository https://gitbox.apache.org/repos/asf/incubator-linkis.git
commit 5d49bd3e30acfbaae3004244228d46f9495e310f
Author: xiaojie19852006 <xi...@163.com>
AuthorDate: Wed Mar 9 10:42:15 2022 +0800
add spotless format for unit test
---
.../core/restful/DataSourceCoreRestfulApi.java | 66 ++--
.../apache/linkis/datasourcemanager/core/Scan.java | 3 +-
.../datasourcemanager/core/dao/BaseDaoTest.java | 6 +-
.../core/dao/DataSourceDaoTest.java | 90 ++---
.../core/dao/DataSourceEnvDaoTest.java | 50 +--
.../core/dao/DataSourceParamKeyDaoTest.java | 31 +-
.../core/dao/DataSourceTypeDaoTest.java | 21 +-
.../core/dao/DataSourceVersionDaoTest.java | 33 +-
.../restful/DataSourceAdminRestfulApiTest.java | 142 ++++---
.../core/restful/DataSourceCoreRestfulApiTest.java | 429 ++++++++++++++-------
.../restful/DataSourceOperateRestfulApiTest.java | 17 +-
.../datasourcemanager/core/restful/MvcUtils.java | 9 +-
.../core/service/BmlAppServiceTest.java | 17 +-
.../core/service/DataSourceInfoServiceTest.java | 187 +++++----
.../core/service/DataSourceRelateServiceTest.java | 14 +-
.../core/service/MetadataOperateServiceTest.java | 39 +-
.../server/WebApplicationServer.java | 3 +-
.../server/restful/MetadataCoreRestfulTest.java | 221 ++++++-----
.../metadatamanager/server/restful/MvcUtils.java | 9 +-
19 files changed, 815 insertions(+), 572 deletions(-)
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/main/java/org/apache/linkis/datasourcemanager/core/restful/DataSourceCoreRestfulApi.java b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/main/java/org/apache/linkis/datasourcemanager/core/restful/DataSourceCoreRestfulApi.java
index 744b238..bae84c6 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/main/java/org/apache/linkis/datasourcemanager/core/restful/DataSourceCoreRestfulApi.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/main/java/org/apache/linkis/datasourcemanager/core/restful/DataSourceCoreRestfulApi.java
@@ -51,7 +51,6 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.UnsupportedEncodingException;
-import java.net.URLEncoder;
import java.util.*;
@RestController
@@ -231,9 +230,8 @@ public class DataSourceCoreRestfulApi {
return RestfulApiHelper.doAndResponse(
() -> {
DataSource dataSource = dataSourceInfoService.getDataSourceInfo(dataSourceId);
- if(dataSource == null){
- return Message.error(
- "No Exists The DataSource [不存在改数据源]");
+ if (dataSource == null) {
+ return Message.error("No Exists The DataSource [不存在改数据源]");
}
if (!AuthContext.hasPermission(dataSource, request)) {
return Message.error(
@@ -241,9 +239,9 @@ public class DataSourceCoreRestfulApi {
}
// Decrypt
RestfulApiHelper.decryptPasswordKey(
- dataSourceRelateService.getKeyDefinitionsByType(
- dataSource.getDataSourceTypeId()),
- dataSource.getConnectParams());
+ dataSourceRelateService.getKeyDefinitionsByType(
+ dataSource.getDataSourceTypeId()),
+ dataSource.getConnectParams());
return Message.ok().data("info", dataSource);
},
"Fail to access data source[获取数据源信息失败]");
@@ -257,9 +255,8 @@ public class DataSourceCoreRestfulApi {
() -> {
DataSource dataSource = dataSourceInfoService.getDataSourceInfo(dataSourceName);
- if(dataSource == null){
- return Message.error(
- "No Exists The DataSource [不存在改数据源]");
+ if (dataSource == null) {
+ return Message.error("No Exists The DataSource [不存在改数据源]");
}
if (!AuthContext.hasPermission(dataSource, request)) {
@@ -268,9 +265,9 @@ public class DataSourceCoreRestfulApi {
}
// Decrypt
RestfulApiHelper.decryptPasswordKey(
- dataSourceRelateService.getKeyDefinitionsByType(
- dataSource.getDataSourceTypeId()),
- dataSource.getConnectParams());
+ dataSourceRelateService.getKeyDefinitionsByType(
+ dataSource.getDataSourceTypeId()),
+ dataSource.getConnectParams());
return Message.ok().data("info", dataSource);
},
@@ -294,9 +291,8 @@ public class DataSourceCoreRestfulApi {
DataSource dataSource =
dataSourceInfoService.getDataSourceInfo(dataSourceId, version);
- if(dataSource == null){
- return Message.error(
- "No Exists The DataSource [不存在改数据源]");
+ if (dataSource == null) {
+ return Message.error("No Exists The DataSource [不存在改数据源]");
}
if (!AuthContext.hasPermission(dataSource, request)) {
@@ -328,9 +324,8 @@ public class DataSourceCoreRestfulApi {
DataSource dataSource =
dataSourceInfoService.getDataSourceInfoBrief(dataSourceId);
- if(dataSource == null){
- return Message.error(
- "No Exists The DataSource [不存在改数据源]");
+ if (dataSource == null) {
+ return Message.error("No Exists The DataSource [不存在改数据源]");
}
if (!AuthContext.hasPermission(dataSource, request)) {
@@ -365,9 +360,8 @@ public class DataSourceCoreRestfulApi {
DataSource dataSource =
dataSourceInfoService.getDataSourceInfoBrief(dataSourceId);
- if(dataSource == null){
- return Message.error(
- "No Exists The DataSource [不存在改数据源]");
+ if (dataSource == null) {
+ return Message.error("No Exists The DataSource [不存在改数据源]");
}
if (!AuthContext.hasPermission(dataSource, request)) {
@@ -399,9 +393,8 @@ public class DataSourceCoreRestfulApi {
DataSource dataSource =
dataSourceInfoService.getDataSourceInfoBrief(dataSourceId);
- if(dataSource == null){
- return Message.error(
- "No Exists The DataSource [不存在改数据源]");
+ if (dataSource == null) {
+ return Message.error("No Exists The DataSource [不存在改数据源]");
}
if (!AuthContext.hasPermission(dataSource, request)) {
@@ -427,9 +420,8 @@ public class DataSourceCoreRestfulApi {
DataSource dataSource =
dataSourceInfoService.getDataSourceInfoBrief(dataSourceId);
- if(dataSource == null){
- return Message.error(
- "No Exists The DataSource [不存在改数据源]");
+ if (dataSource == null) {
+ return Message.error("No Exists The DataSource [不存在改数据源]");
}
if (!AuthContext.hasPermission(dataSource, request)) {
@@ -461,9 +453,8 @@ public class DataSourceCoreRestfulApi {
DataSource dataSource =
dataSourceInfoService.getDataSourceInfoForConnect(dataSourceId);
- if(dataSource == null){
- return Message.error(
- "No Exists The DataSource [不存在改数据源]");
+ if (dataSource == null) {
+ return Message.error("No Exists The DataSource [不存在改数据源]");
}
if (!AuthContext.hasPermission(dataSource, req)) {
@@ -489,9 +480,8 @@ public class DataSourceCoreRestfulApi {
DataSource dataSource =
dataSourceInfoService.getDataSourceInfoForConnect(dataSourceName);
- if(dataSource == null){
- return Message.error(
- "No Exists The DataSource [不存在改数据源]");
+ if (dataSource == null) {
+ return Message.error("No Exists The DataSource [不存在改数据源]");
}
if (!AuthContext.hasPermission(dataSource, req)) {
@@ -504,7 +494,8 @@ public class DataSourceCoreRestfulApi {
dataSource.getDataSourceTypeId()),
connectParams);
return Message.ok().data("connectParams", connectParams);
- }, "Fail to connect data source[连接数据源失败]");
+ },
+ "Fail to connect data source[连接数据源失败]");
}
@RequestMapping(value = "/{data_source_id}/{version}/op/connect", method = RequestMethod.PUT)
@@ -518,9 +509,8 @@ public class DataSourceCoreRestfulApi {
DataSource dataSource =
dataSourceInfoService.getDataSourceInfoForConnect(
dataSourceId, version);
- if(dataSource == null){
- return Message.error(
- "No Exists The DataSource [不存在改数据源]");
+ if (dataSource == null) {
+ return Message.error("No Exists The DataSource [不存在改数据源]");
}
if (!AuthContext.hasPermission(dataSource, req)) {
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/Scan.java b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/Scan.java
index 6293c13..802a35e 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/Scan.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/Scan.java
@@ -17,9 +17,10 @@
package org.apache.linkis.datasourcemanager.core;
-import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.mybatis.spring.annotation.MapperScan;
+
@EnableAutoConfiguration
@MapperScan("org.apache.linkis.datasourcemanager.core.dao")
public class Scan {}
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/BaseDaoTest.java b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/BaseDaoTest.java
index d4f1f0f..4579a72 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/BaseDaoTest.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/BaseDaoTest.java
@@ -18,16 +18,14 @@
package org.apache.linkis.datasourcemanager.core.dao;
import org.apache.linkis.datasourcemanager.core.Scan;
+
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.Rollback;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.Transactional;
-
@SpringBootTest(classes = Scan.class)
@Transactional
@Rollback(true)
@EnableTransactionManagement
-public abstract class BaseDaoTest {
-
-}
+public abstract class BaseDaoTest {}
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceDaoTest.java b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceDaoTest.java
index f4cce23..9c4d892 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceDaoTest.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceDaoTest.java
@@ -19,6 +19,9 @@ package org.apache.linkis.datasourcemanager.core.dao;
import org.apache.linkis.datasourcemanager.common.domain.DataSource;
import org.apache.linkis.datasourcemanager.core.vo.DataSourceVo;
+
+import org.springframework.beans.factory.annotation.Autowired;
+
import org.h2.tools.Server;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
@@ -26,7 +29,6 @@ import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
import java.util.Date;
import java.util.List;
@@ -34,8 +36,7 @@ import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.*;
-
-class DataSourceDaoTest extends BaseDaoTest{
+class DataSourceDaoTest extends BaseDaoTest {
private static final Logger logger = LoggerFactory.getLogger(DataSourceDaoTest.class);
@Autowired DataSourceDao dataSourceDao;
@@ -45,7 +46,7 @@ class DataSourceDaoTest extends BaseDaoTest{
*
* @return DataSource
*/
- private DataSource insertOne(){
+ private DataSource insertOne() {
DataSource dataSource = new DataSource();
dataSource.setDataSourceName("unitTest");
dataSource.setDataSourceTypeId(1l);
@@ -66,8 +67,6 @@ class DataSourceDaoTest extends BaseDaoTest{
protected static void beforeAll() throws Exception {
// Start the console of h2 to facilitate viewing of h2 data
Server.createWebServer("-web", "-webAllowOthers", "-webPort", "8082").start();
-
-
}
@AfterAll
@@ -75,64 +74,64 @@ class DataSourceDaoTest extends BaseDaoTest{
protected static void afterAll() throws Exception {}
@Test
- void testInsertOne(){
+ void testInsertOne() {
DataSource dataSource = insertOne();
- assertTrue(dataSource.getId()>0);
+ assertTrue(dataSource.getId() > 0);
}
@Test
- void testSelectOneDetail(){
+ void testSelectOneDetail() {
DataSource dataSource = insertOne();
DataSource result = dataSourceDao.selectOneDetail(dataSource.getId());
- assertEquals("mysql",result.getDataSourceType().getName());
+ assertEquals("mysql", result.getDataSourceType().getName());
}
@Test
- void testSelectOneDetailByName(){
+ void testSelectOneDetailByName() {
DataSource dataSource = insertOne();
DataSource result = dataSourceDao.selectOneDetailByName(dataSource.getDataSourceName());
- assertEquals("mysql",result.getDataSourceType().getName());
+ assertEquals("mysql", result.getDataSourceType().getName());
}
@Test
- void testSelectOne(){
+ void testSelectOne() {
DataSource dataSource = insertOne();
DataSource result = dataSourceDao.selectOne(dataSource.getId());
- assertTrue(result.getId()>0);
+ assertTrue(result.getId() > 0);
}
@Test
- void testSelectOneByName(){
+ void testSelectOneByName() {
DataSource dataSource = insertOne();
DataSource result = dataSourceDao.selectOneByName(dataSource.getDataSourceName());
- assertTrue(result.getId()>0);
+ assertTrue(result.getId() > 0);
}
@Test
- void testRemoveOne(){
+ void testRemoveOne() {
DataSource dataSource = insertOne();
int res = dataSourceDao.removeOne(dataSource.getId());
assertTrue(res == 1);
}
@Test
- void testExpireOne(){
+ void testExpireOne() {
DataSource dataSource = insertOne();
int res = dataSourceDao.expireOne(dataSource.getId());
assertTrue(res == 1);
}
@Test
- void testUpdateOne(){
+ void testUpdateOne() {
DataSource dataSource = insertOne();
dataSource = dataSourceDao.selectOne(dataSource.getId());
- dataSource.setDataSourceName("modify "+"unitTest");
+ dataSource.setDataSourceName("modify " + "unitTest");
dataSource.setDataSourceTypeId(1l);
- dataSource.setDataSourceDesc("modify "+"unit test by h2 database");
- dataSource.setCreateIdentify("modify "+"unitTest");
- dataSource.setCreateSystem("modify "+"local");
+ dataSource.setDataSourceDesc("modify " + "unit test by h2 database");
+ dataSource.setCreateIdentify("modify " + "unitTest");
+ dataSource.setCreateSystem("modify " + "local");
dataSource.setParameter("{}");
- dataSource.setModifyUser("modify "+"test");
+ dataSource.setModifyUser("modify " + "test");
dataSource.setModifyTime(new Date());
dataSourceDao.updateOne(dataSource);
DataSource newDataSource = dataSourceDao.selectOne(dataSource.getId());
@@ -140,30 +139,30 @@ class DataSourceDaoTest extends BaseDaoTest{
}
@Test
- void testSelectByPageVo(){
+ void testSelectByPageVo() {
Date originDate = new Date();
- //match
+ // match
DataSource dataSource = insertOne();
- //match
+ // match
dataSource.setDataSourceName("unitTest1");
dataSource.setCreateTime(new Date());
dataSourceDao.insertOne(dataSource);
- //match
+ // match
dataSource.setDataSourceName("unitTest2");
dataSource.setCreateTime(originDate);
dataSourceDao.insertOne(dataSource);
- //no match by datasource name
+ // no match by datasource name
dataSource.setDataSourceName("tmpTest");
dataSourceDao.insertOne(dataSource);
- //on match by dataSourceTypeId
+ // on match by dataSourceTypeId
dataSource.setDataSourceName("unitTest3");
dataSource.setDataSourceTypeId(2l);
dataSourceDao.insertOne(dataSource);
- //no match by createUser
+ // no match by createUser
dataSource.setDataSourceName("unitTest4");
dataSource.setDataSourceTypeId(1l);
dataSource.setCreateUser("other");
@@ -175,26 +174,27 @@ class DataSourceDaoTest extends BaseDaoTest{
dataSourceVo.setPermissionUser("test");
List<DataSource> dataSources = dataSourceDao.selectByPageVo(dataSourceVo);
- assertAll("All",()->
- assertTrue(dataSources.size()==3),
- ()->assertTrue("unitTest".equals(dataSources.get(1).getDataSourceName())),
- ()->assertTrue("unitTest1".equals(dataSources.get(0).getDataSourceName())),
- ()->assertTrue("unitTest2".equals(dataSources.get(2).getDataSourceName()))
- );
+ assertAll(
+ "All",
+ () -> assertTrue(dataSources.size() == 3),
+ () -> assertTrue("unitTest".equals(dataSources.get(1).getDataSourceName())),
+ () -> assertTrue("unitTest1".equals(dataSources.get(0).getDataSourceName())),
+ () -> assertTrue("unitTest2".equals(dataSources.get(2).getDataSourceName())));
}
@Test
- void testSetPublishedVersionId(){
+ void testSetPublishedVersionId() {
DataSource dataSource = insertOne();
- dataSourceDao.setPublishedVersionId(dataSource.getId(),10l);
- assertTrue(dataSourceDao.selectByPageVo(new DataSourceVo()).get(0).getPublishedVersionId()==10l);
+ dataSourceDao.setPublishedVersionId(dataSource.getId(), 10l);
+ assertTrue(
+ dataSourceDao.selectByPageVo(new DataSourceVo()).get(0).getPublishedVersionId()
+ == 10l);
}
@Test
- void testUpdateVersionId(){
+ void testUpdateVersionId() {
DataSource dataSource = insertOne();
- dataSourceDao.updateVersionId(dataSource.getId(),10l);
- assertTrue(dataSourceDao.selectByPageVo(new DataSourceVo()).get(0).getVersionId()==10l);
+ dataSourceDao.updateVersionId(dataSource.getId(), 10l);
+ assertTrue(dataSourceDao.selectByPageVo(new DataSourceVo()).get(0).getVersionId() == 10l);
}
-
-}
\ No newline at end of file
+}
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceEnvDaoTest.java b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceEnvDaoTest.java
index 1d2d1f4..1f00a0c 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceEnvDaoTest.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceEnvDaoTest.java
@@ -19,12 +19,14 @@ package org.apache.linkis.datasourcemanager.core.dao;
import org.apache.linkis.datasourcemanager.common.domain.DataSourceEnv;
import org.apache.linkis.datasourcemanager.core.vo.DataSourceEnvVo;
+
+import org.springframework.beans.factory.annotation.Autowired;
+
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
import java.util.Date;
import java.util.List;
@@ -32,8 +34,7 @@ import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.*;
-
-class DataSourceEnvDaoTest extends BaseDaoTest{
+class DataSourceEnvDaoTest extends BaseDaoTest {
private static final Logger logger = LoggerFactory.getLogger(DataSourceEnvDaoTest.class);
@Autowired DataSourceEnvDao dataSourceEnvDao;
@@ -43,7 +44,7 @@ class DataSourceEnvDaoTest extends BaseDaoTest{
*
* @return DataSourceEnv
*/
- private DataSourceEnv insertOne(){
+ private DataSourceEnv insertOne() {
DataSourceEnv dataSourceEnv = new DataSourceEnv();
dataSourceEnv.setEnvName("testEnv");
dataSourceEnv.setEnvDesc("testEnv desc");
@@ -62,34 +63,35 @@ class DataSourceEnvDaoTest extends BaseDaoTest{
protected static void afterAll() throws Exception {}
@Test
- void testInsertOne(){
+ void testInsertOne() {
DataSourceEnv dataSourceEnv = insertOne();
- assertTrue(dataSourceEnv.getId()>0);
+ assertTrue(dataSourceEnv.getId() > 0);
}
@Test
- void testSelectOneDetail(){
+ void testSelectOneDetail() {
DataSourceEnv dataSourceEnv = insertOne();
DataSourceEnv result = dataSourceEnvDao.selectOneDetail(dataSourceEnv.getId());
- assertTrue(result.getId()>0);
+ assertTrue(result.getId() > 0);
}
@Test
- void testListByTypeId(){
+ void testListByTypeId() {
DataSourceEnv dataSourceEnv = insertOne();
- List<DataSourceEnv> dataSourceEnvs = dataSourceEnvDao.listByTypeId(dataSourceEnv.getDataSourceTypeId());
+ List<DataSourceEnv> dataSourceEnvs =
+ dataSourceEnvDao.listByTypeId(dataSourceEnv.getDataSourceTypeId());
assertTrue(dataSourceEnvs.size() == 1);
}
@Test
- void testRemoveOne(){
+ void testRemoveOne() {
DataSourceEnv dataSourceEnv = insertOne();
int res = dataSourceEnvDao.removeOne(dataSourceEnv.getId());
assertTrue(res == 1);
}
@Test
- void testUpdateOne(){
+ void testUpdateOne() {
DataSourceEnv dataSourceEnv = insertOne();
dataSourceEnv = dataSourceEnvDao.selectOneDetail(dataSourceEnv.getId());
dataSourceEnv.setEnvName("modify-testEnv");
@@ -98,23 +100,23 @@ class DataSourceEnvDaoTest extends BaseDaoTest{
dataSourceEnv.setModifyTime(new Date());
dataSourceEnv.setModifyUser("modify-test");
dataSourceEnvDao.updateOne(dataSourceEnv);
- DataSourceEnv newDataSourceEnv =dataSourceEnvDao.selectOneDetail(dataSourceEnv.getId());
+ DataSourceEnv newDataSourceEnv = dataSourceEnvDao.selectOneDetail(dataSourceEnv.getId());
assertThat(newDataSourceEnv).usingRecursiveComparison().isEqualTo(dataSourceEnv);
}
@Test
- void testSelectByPageVo(){
- //match
+ void testSelectByPageVo() {
+ // match
DataSourceEnv dataSourceEnv = insertOne();
- //match
+ // match
dataSourceEnv.setEnvName("testEnv1");
dataSourceEnvDao.insertOne(dataSourceEnv);
- //no match by env name
+ // no match by env name
dataSourceEnv.setEnvName("devEnv1");
dataSourceEnvDao.insertOne(dataSourceEnv);
- //on match by dataSourceTypeId
+ // on match by dataSourceTypeId
dataSourceEnv.setEnvName("testEnv2");
dataSourceEnv.setDataSourceTypeId(2l);
dataSourceEnvDao.insertOne(dataSourceEnv);
@@ -124,10 +126,10 @@ class DataSourceEnvDaoTest extends BaseDaoTest{
dataSourceEnvVo.setDataSourceTypeId(1l);
List<DataSourceEnv> dataSourceEnvs = dataSourceEnvDao.selectByPageVo(dataSourceEnvVo);
- assertAll("All",()->
- assertTrue(dataSourceEnvs.size()==2),
- ()->assertTrue("testEnv".equals(dataSourceEnvs.get(0).getEnvName())),
- ()->assertTrue("testEnv1".equals(dataSourceEnvs.get(1).getEnvName())));
+ assertAll(
+ "All",
+ () -> assertTrue(dataSourceEnvs.size() == 2),
+ () -> assertTrue("testEnv".equals(dataSourceEnvs.get(0).getEnvName())),
+ () -> assertTrue("testEnv1".equals(dataSourceEnvs.get(1).getEnvName())));
}
-
-}
\ No newline at end of file
+}
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceParamKeyDaoTest.java b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceParamKeyDaoTest.java
index 92e3f07..79266e9 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceParamKeyDaoTest.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceParamKeyDaoTest.java
@@ -17,25 +17,21 @@
package org.apache.linkis.datasourcemanager.core.dao;
-import org.apache.linkis.datasourcemanager.common.domain.DataSourceEnv;
import org.apache.linkis.datasourcemanager.common.domain.DataSourceParamKeyDefinition;
-import org.apache.linkis.datasourcemanager.core.vo.DataSourceEnvVo;
+
+import org.springframework.beans.factory.annotation.Autowired;
+
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-import java.util.Date;
import java.util.List;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertTrue;
-
-class DataSourceParamKeyDaoTest extends BaseDaoTest{
+class DataSourceParamKeyDaoTest extends BaseDaoTest {
private static final Logger logger = LoggerFactory.getLogger(DataSourceParamKeyDaoTest.class);
@Autowired DataSourceParamKeyDao dataSourceParamKeyDao;
@@ -45,16 +41,17 @@ class DataSourceParamKeyDaoTest extends BaseDaoTest{
protected static void afterAll() throws Exception {}
@Test
- void testListByDataSourceType(){
- List<DataSourceParamKeyDefinition> dataSourceParamKeyDefinitions = dataSourceParamKeyDao.listByDataSourceType(1l);
- assertTrue(dataSourceParamKeyDefinitions.size()==2);
+ void testListByDataSourceType() {
+ List<DataSourceParamKeyDefinition> dataSourceParamKeyDefinitions =
+ dataSourceParamKeyDao.listByDataSourceType(1l);
+ assertTrue(dataSourceParamKeyDefinitions.size() == 2);
}
@Test
- void testListByDataSourceTypeAndScope(){
- List<DataSourceParamKeyDefinition> dataSourceParamKeyDefinitions = dataSourceParamKeyDao.listByDataSourceTypeAndScope(1l,DataSourceParamKeyDefinition.Scope.ENV);
- assertTrue(dataSourceParamKeyDefinitions.size()==1);
+ void testListByDataSourceTypeAndScope() {
+ List<DataSourceParamKeyDefinition> dataSourceParamKeyDefinitions =
+ dataSourceParamKeyDao.listByDataSourceTypeAndScope(
+ 1l, DataSourceParamKeyDefinition.Scope.ENV);
+ assertTrue(dataSourceParamKeyDefinitions.size() == 1);
}
-
-
-}
\ No newline at end of file
+}
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceTypeDaoTest.java b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceTypeDaoTest.java
index 06b341e..c1af0cb 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceTypeDaoTest.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceTypeDaoTest.java
@@ -17,21 +17,17 @@
package org.apache.linkis.datasourcemanager.core.dao;
+import org.springframework.beans.factory.annotation.Autowired;
+
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-
-import java.util.Date;
-import java.util.List;
-import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.*;
-
-class DataSourceTypeDaoTest extends BaseDaoTest{
+class DataSourceTypeDaoTest extends BaseDaoTest {
private static final Logger logger = LoggerFactory.getLogger(DataSourceTypeDaoTest.class);
@Autowired DataSourceTypeDao dataSourceTypeDao;
@@ -41,15 +37,12 @@ class DataSourceTypeDaoTest extends BaseDaoTest{
protected static void afterAll() throws Exception {}
@Test
- void testGetAllTypes(){
- assertTrue(dataSourceTypeDao.getAllTypes().size()==1);
+ void testGetAllTypes() {
+ assertTrue(dataSourceTypeDao.getAllTypes().size() == 1);
}
@Test
- void testSelectOne(){
+ void testSelectOne() {
assertNotNull(dataSourceTypeDao.selectOne(1l));
}
-
-
-
-}
\ No newline at end of file
+}
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceVersionDaoTest.java b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceVersionDaoTest.java
index 240eed8..4c8eb04 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceVersionDaoTest.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/dao/DataSourceVersionDaoTest.java
@@ -18,24 +18,23 @@
package org.apache.linkis.datasourcemanager.core.dao;
import org.apache.linkis.datasourcemanager.common.domain.DatasourceVersion;
+
+import org.springframework.beans.factory.annotation.Autowired;
+
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
import java.util.Date;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
-
-class DataSourceVersionDaoTest extends BaseDaoTest{
+class DataSourceVersionDaoTest extends BaseDaoTest {
private static final Logger logger = LoggerFactory.getLogger(DataSourceVersionDaoTest.class);
- @Autowired
- DataSourceVersionDao dataSourceVersionDao;
+ @Autowired DataSourceVersionDao dataSourceVersionDao;
@AfterAll
@DisplayName("Each unit test method is executed once before execution")
@@ -47,7 +46,7 @@ class DataSourceVersionDaoTest extends BaseDaoTest{
*
* @return DataSource
*/
- private DatasourceVersion insertOne(){
+ private DatasourceVersion insertOne() {
DatasourceVersion datasourceVersion = new DatasourceVersion();
datasourceVersion.setVersionId(1l);
datasourceVersion.setDatasourceId(1l);
@@ -64,34 +63,34 @@ class DataSourceVersionDaoTest extends BaseDaoTest{
}
@Test
- void testInsertOne(){
+ void testInsertOne() {
insertOne();
- assertTrue(dataSourceVersionDao.getLatestVersion(1l)==2l);
+ assertTrue(dataSourceVersionDao.getLatestVersion(1l) == 2l);
}
@Test
- void testGetLatestVersion(){
+ void testGetLatestVersion() {
insertOne();
- assertTrue(dataSourceVersionDao.getLatestVersion(1l)==2l);
+ assertTrue(dataSourceVersionDao.getLatestVersion(1l) == 2l);
}
+
@Test
- void testSelectOneVersion(){
+ void testSelectOneVersion() {
insertOne();
String param = dataSourceVersionDao.selectOneVersion(1l, 2l);
assertTrue("a:b".equals(param));
}
@Test
- void testGetVersionsFromDatasourceId(){
+ void testGetVersionsFromDatasourceId() {
insertOne();
- assertTrue(dataSourceVersionDao.getVersionsFromDatasourceId(1l).size()==2);
+ assertTrue(dataSourceVersionDao.getVersionsFromDatasourceId(1l).size() == 2);
}
@Test
- void testRemoveFromDataSourceId(){
+ void testRemoveFromDataSourceId() {
insertOne();
int res = dataSourceVersionDao.removeFromDataSourceId(1l);
assertTrue(res == 2);
}
-
-}
\ No newline at end of file
+}
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/restful/DataSourceAdminRestfulApiTest.java b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/restful/DataSourceAdminRestfulApiTest.java
index 8264111..e9720c3 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/restful/DataSourceAdminRestfulApiTest.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/restful/DataSourceAdminRestfulApiTest.java
@@ -26,24 +26,29 @@ import org.apache.linkis.datasourcemanager.core.validate.ParameterValidator;
import org.apache.linkis.server.Message;
import org.apache.linkis.server.MessageStatus;
import org.apache.linkis.server.security.SecurityFilter;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.MockedStatic;
-import org.mockito.Mockito;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.web.servlet.MockMvc;
+
import javax.servlet.http.HttpServletRequest;
import javax.validation.Validator;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
import java.io.StringWriter;
import java.util.*;
+
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.isA;
@@ -53,32 +58,29 @@ import static org.mockito.Mockito.times;
@AutoConfigureMockMvc
@SpringBootTest(classes = {WebApplicationServer.class, Scan.class})
class DataSourceAdminRestfulApiTest {
- private static final Logger logger = LoggerFactory.getLogger(DataSourceAdminRestfulApiTest.class);
-
+ private static final Logger logger =
+ LoggerFactory.getLogger(DataSourceAdminRestfulApiTest.class);
- @Autowired
- protected MockMvc mockMvc;
+ @Autowired protected MockMvc mockMvc;
- @MockBean
- private Validator beanValidator;
+ @MockBean private Validator beanValidator;
- @MockBean
- private ParameterValidator parameterValidator;
+ @MockBean private ParameterValidator parameterValidator;
- @MockBean
- private DataSourceInfoService dataSourceInfoService;
+ @MockBean private DataSourceInfoService dataSourceInfoService;
private static MockedStatic<SecurityFilter> securityFilter;
@BeforeAll
- private static void init(){
+ private static void init() {
securityFilter = Mockito.mockStatic(SecurityFilter.class);
}
@AfterAll
- private static void close(){
+ private static void close() {
securityFilter.close();
}
+
@Test
void insertJsonEnv() throws Exception {
long dataSourceEnvId = 10l;
@@ -87,76 +89,105 @@ class DataSourceAdminRestfulApiTest {
DataSourceEnv dataSourceEnv = new DataSourceEnv();
dataSourceEnv.setId(dataSourceEnvId);
StringWriter dsJsonWriter = new StringWriter();
- JsonUtils.jackson().writeValue(dsJsonWriter,dataSourceEnv);
- securityFilter.when(()->SecurityFilter.getLoginUsername(isA(HttpServletRequest.class))).thenReturn("testUser","hadoop");
- Message mvcResult = mvcUtils.getMessage(mvcUtils.buildMvcResultPost(url,dsJsonWriter.toString()));
- assertTrue(MessageStatus.ERROR() == mvcResult.getStatus() && mvcResult.getMessage().contains("is not admin user"));
-
- mvcResult = mvcUtils.getMessage(mvcUtils.buildMvcResultPost(url,dsJsonWriter.toString()));
-
- Mockito.doNothing().when(parameterValidator).validate(any(),any());
+ JsonUtils.jackson().writeValue(dsJsonWriter, dataSourceEnv);
+ securityFilter
+ .when(() -> SecurityFilter.getLoginUsername(isA(HttpServletRequest.class)))
+ .thenReturn("testUser", "hadoop");
+ Message mvcResult =
+ mvcUtils.getMessage(mvcUtils.buildMvcResultPost(url, dsJsonWriter.toString()));
+ assertTrue(
+ MessageStatus.ERROR() == mvcResult.getStatus()
+ && mvcResult.getMessage().contains("is not admin user"));
+
+ mvcResult = mvcUtils.getMessage(mvcUtils.buildMvcResultPost(url, dsJsonWriter.toString()));
+
+ Mockito.doNothing().when(parameterValidator).validate(any(), any());
Mockito.doNothing().when(dataSourceInfoService).saveDataSourceEnv(any());
- assertTrue(MessageStatus.SUCCESS() == mvcResult.getStatus() && "10".equals(mvcResult.getData().get("insert_id").toString()));
+ assertTrue(
+ MessageStatus.SUCCESS() == mvcResult.getStatus()
+ && "10".equals(mvcResult.getData().get("insert_id").toString()));
}
@Test
void getAllEnvListByDataSourceType() throws Exception {
long dataSourceEnvTypeId = 10l;
- String url = String.format("/data-source-manager/env_list/all/type/%s",dataSourceEnvTypeId);
+ String url =
+ String.format("/data-source-manager/env_list/all/type/%s", dataSourceEnvTypeId);
MvcUtils mvcUtils = new MvcUtils(mockMvc);
List<DataSourceEnv> envList = new ArrayList<>();
- Mockito.when(dataSourceInfoService.listDataSourceEnvByType(dataSourceEnvTypeId)).thenReturn(envList);
+ Mockito.when(dataSourceInfoService.listDataSourceEnvByType(dataSourceEnvTypeId))
+ .thenReturn(envList);
Message mvcResult = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
assertTrue(MessageStatus.SUCCESS() == mvcResult.getStatus());
- Mockito.verify(dataSourceInfoService,times(1)).listDataSourceEnvByType(dataSourceEnvTypeId);
+ Mockito.verify(dataSourceInfoService, times(1))
+ .listDataSourceEnvByType(dataSourceEnvTypeId);
}
@Test
void getEnvEntityById() throws Exception {
long dataSourceEnvId = 10l;
- String url = String.format("/data-source-manager/env/%s",dataSourceEnvId);
+ String url = String.format("/data-source-manager/env/%s", dataSourceEnvId);
MvcUtils mvcUtils = new MvcUtils(mockMvc);
List<DataSourceEnv> envList = new ArrayList<>();
- Mockito.when(dataSourceInfoService.getDataSourceEnv(dataSourceEnvId)).thenReturn(new DataSourceEnv());
+ Mockito.when(dataSourceInfoService.getDataSourceEnv(dataSourceEnvId))
+ .thenReturn(new DataSourceEnv());
Message mvcResult = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
assertTrue(MessageStatus.SUCCESS() == mvcResult.getStatus());
- Mockito.verify(dataSourceInfoService,times(1)).getDataSourceEnv(dataSourceEnvId);
+ Mockito.verify(dataSourceInfoService, times(1)).getDataSourceEnv(dataSourceEnvId);
}
@Test
void removeEnvEntity() throws Exception {
long dataSourceEnvId = 10l;
- String url = String.format("/data-source-manager/env/%s",dataSourceEnvId);
+ String url = String.format("/data-source-manager/env/%s", dataSourceEnvId);
MvcUtils mvcUtils = new MvcUtils(mockMvc);
- securityFilter.when(()->SecurityFilter.getLoginUsername(isA(HttpServletRequest.class))).thenReturn("testUser","hadoop");
+ securityFilter
+ .when(() -> SecurityFilter.getLoginUsername(isA(HttpServletRequest.class)))
+ .thenReturn("testUser", "hadoop");
Message mvcResult = mvcUtils.getMessage(mvcUtils.buildMvcResultDelete(url));
- assertTrue(MessageStatus.ERROR() == mvcResult.getStatus() && mvcResult.getMessage().contains("is not admin user"));
+ assertTrue(
+ MessageStatus.ERROR() == mvcResult.getStatus()
+ && mvcResult.getMessage().contains("is not admin user"));
- Mockito.when(dataSourceInfoService.removeDataSourceEnv(dataSourceEnvId)).thenReturn(dataSourceEnvId);
+ Mockito.when(dataSourceInfoService.removeDataSourceEnv(dataSourceEnvId))
+ .thenReturn(dataSourceEnvId);
mvcResult = mvcUtils.getMessage(mvcUtils.buildMvcResultDelete(url));
- assertTrue(MessageStatus.SUCCESS() == mvcResult.getStatus() && "10".equals(mvcResult.getData().get("remove_id").toString()));
+ assertTrue(
+ MessageStatus.SUCCESS() == mvcResult.getStatus()
+ && "10".equals(mvcResult.getData().get("remove_id").toString()));
}
@Test
void updateJsonEnv() throws Exception {
long dataSourceEnvId = 10l;
- String url = String.format("/data-source-manager/env/%s/json",dataSourceEnvId);
-
+ String url = String.format("/data-source-manager/env/%s/json", dataSourceEnvId);
+
DataSourceEnv dataSourceEnv = new DataSourceEnv();
dataSourceEnv.setId(dataSourceEnvId);
StringWriter dsJsonWriter = new StringWriter();
- JsonUtils.jackson().writeValue(dsJsonWriter,dataSourceEnv);
-
- MvcUtils mvcUtils = new MvcUtils(mockMvc);
- securityFilter.when(()->SecurityFilter.getLoginUsername(isA(HttpServletRequest.class))).thenReturn("testUser","hadoop");
- Message mvcResult = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url,dsJsonWriter.toString()));
- assertTrue(MessageStatus.ERROR() == mvcResult.getStatus() && mvcResult.getMessage().contains("is not admin user"));
-
- Mockito.when(dataSourceInfoService.getDataSourceEnv(dataSourceEnvId)).thenReturn(null).thenReturn(dataSourceEnv);
- mvcResult = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url,dsJsonWriter.toString()));
- assertTrue(MessageStatus.ERROR() == mvcResult.getStatus() && mvcResult.getMessage().contains("Fail to update data source environment"));
+ JsonUtils.jackson().writeValue(dsJsonWriter, dataSourceEnv);
- mvcResult = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url,dsJsonWriter.toString()));
+ MvcUtils mvcUtils = new MvcUtils(mockMvc);
+ securityFilter
+ .when(() -> SecurityFilter.getLoginUsername(isA(HttpServletRequest.class)))
+ .thenReturn("testUser", "hadoop");
+ Message mvcResult =
+ mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url, dsJsonWriter.toString()));
+ assertTrue(
+ MessageStatus.ERROR() == mvcResult.getStatus()
+ && mvcResult.getMessage().contains("is not admin user"));
+
+ Mockito.when(dataSourceInfoService.getDataSourceEnv(dataSourceEnvId))
+ .thenReturn(null)
+ .thenReturn(dataSourceEnv);
+ mvcResult = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url, dsJsonWriter.toString()));
+ assertTrue(
+ MessageStatus.ERROR() == mvcResult.getStatus()
+ && mvcResult
+ .getMessage()
+ .contains("Fail to update data source environment"));
+
+ mvcResult = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url, dsJsonWriter.toString()));
assertTrue(MessageStatus.SUCCESS() == mvcResult.getStatus());
}
@@ -164,9 +195,10 @@ class DataSourceAdminRestfulApiTest {
void queryDataSourceEnv() throws Exception {
String url = String.format("/data-source-manager/env");
MvcUtils mvcUtils = new MvcUtils(mockMvc);
- Mockito.when(dataSourceInfoService.queryDataSourceEnvPage(any())).thenReturn(new ArrayList<>());
+ Mockito.when(dataSourceInfoService.queryDataSourceEnvPage(any()))
+ .thenReturn(new ArrayList<>());
Message mvcResult = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
assertTrue(MessageStatus.SUCCESS() == mvcResult.getStatus());
Mockito.verify(dataSourceInfoService, times(1)).queryDataSourceEnvPage(any());
}
-}
\ No newline at end of file
+}
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/restful/DataSourceCoreRestfulApiTest.java b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/restful/DataSourceCoreRestfulApiTest.java
index 05303ca..e863942 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/restful/DataSourceCoreRestfulApiTest.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/restful/DataSourceCoreRestfulApiTest.java
@@ -17,7 +17,6 @@
package org.apache.linkis.datasourcemanager.core.restful;
-import com.github.pagehelper.PageInfo;
import org.apache.linkis.common.utils.JsonUtils;
import org.apache.linkis.datasourcemanager.common.domain.DataSource;
import org.apache.linkis.datasourcemanager.common.domain.DataSourceParamKeyDefinition;
@@ -32,14 +31,7 @@ import org.apache.linkis.datasourcemanager.core.vo.DataSourceVo;
import org.apache.linkis.server.Message;
import org.apache.linkis.server.MessageStatus;
import org.apache.linkis.server.security.SecurityFilter;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.MockedStatic;
-import org.mockito.Mockito;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
@@ -49,8 +41,20 @@ import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
+
import javax.servlet.http.HttpServletRequest;
import javax.validation.Validator;
+
+import com.github.pagehelper.PageInfo;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
import java.io.StringWriter;
import java.util.*;
@@ -61,39 +65,33 @@ import static org.mockito.ArgumentMatchers.*;
@ExtendWith({SpringExtension.class})
@AutoConfigureMockMvc
-@SpringBootTest(classes = {WebApplicationServer.class,Scan.class})
+@SpringBootTest(classes = {WebApplicationServer.class, Scan.class})
class DataSourceCoreRestfulApiTest {
- private static final Logger logger = LoggerFactory.getLogger(DataSourceCoreRestfulApiTest.class);
-
- @Autowired
- protected MockMvc mockMvc;
+ private static final Logger logger =
+ LoggerFactory.getLogger(DataSourceCoreRestfulApiTest.class);
- @MockBean
- private DataSourceRelateService dataSourceRelateService;
+ @Autowired protected MockMvc mockMvc;
- @MockBean
- private DataSourceInfoService dataSourceInfoService;
+ @MockBean private DataSourceRelateService dataSourceRelateService;
+ @MockBean private DataSourceInfoService dataSourceInfoService;
- @MockBean
- private Validator beanValidator;
+ @MockBean private Validator beanValidator;
- @MockBean
- ParameterValidator parameterValidator;
+ @MockBean ParameterValidator parameterValidator;
- @MockBean
- MetadataOperateService metadataOperateService;
+ @MockBean MetadataOperateService metadataOperateService;
private static MockedStatic<SecurityFilter> securityFilter;
@BeforeAll
- private static void init(){
+ private static void init() {
securityFilter = Mockito.mockStatic(SecurityFilter.class);
}
@AfterAll
- private static void close(){
+ private static void close() {
securityFilter.close();
}
@@ -104,7 +102,9 @@ class DataSourceCoreRestfulApiTest {
Mockito.when(dataSourceRelateService.getAllDataSourceTypes()).thenReturn(dataSourceTypes);
MvcResult mvcResult = mvcUtils.buildMvcResultGet("/data-source-manager/type/all");
Message res = mvcUtils.getMessage(mvcResult);
- assertThat(dataSourceTypes).usingRecursiveComparison().isEqualTo(res.getData().get("type_list"));
+ assertThat(dataSourceTypes)
+ .usingRecursiveComparison()
+ .isEqualTo(res.getData().get("type_list"));
}
@Test
@@ -112,10 +112,15 @@ class DataSourceCoreRestfulApiTest {
MvcUtils mvcUtils = new MvcUtils(mockMvc);
Long dataSourceTypeId = 1l;
List<DataSourceParamKeyDefinition> keyDefinitions = new ArrayList<>();
- Mockito.when(dataSourceRelateService.getKeyDefinitionsByType(dataSourceTypeId)).thenReturn(keyDefinitions);
- MvcResult mvcResult = mvcUtils.buildMvcResultGet(String.format("/data-source-manager/key_define/type/%s",dataSourceTypeId));
+ Mockito.when(dataSourceRelateService.getKeyDefinitionsByType(dataSourceTypeId))
+ .thenReturn(keyDefinitions);
+ MvcResult mvcResult =
+ mvcUtils.buildMvcResultGet(
+ String.format("/data-source-manager/key_define/type/%s", dataSourceTypeId));
Message res = mvcUtils.getMessage(mvcResult);
- assertThat(keyDefinitions).usingRecursiveComparison().isEqualTo(res.getData().get("key_define"));
+ assertThat(keyDefinitions)
+ .usingRecursiveComparison()
+ .isEqualTo(res.getData().get("key_define"));
}
@Test
@@ -124,15 +129,21 @@ class DataSourceCoreRestfulApiTest {
DataSource dataSource = new DataSource();
dataSource.setDataSourceName("test");
StringWriter dsJsonWriter = new StringWriter();
- JsonUtils.jackson().writeValue(dsJsonWriter,dataSource);
+ JsonUtils.jackson().writeValue(dsJsonWriter, dataSource);
Mockito.doNothing().when(dataSourceInfoService).saveDataSourceInfo(dataSource);
- MvcResult mvcResult = mvcUtils.buildMvcResultPost("/data-source-manager/info/json",dsJsonWriter.toString());
+ MvcResult mvcResult =
+ mvcUtils.buildMvcResultPost(
+ "/data-source-manager/info/json", dsJsonWriter.toString());
Message res = mvcUtils.getMessage(mvcResult);
assertEquals(MessageStatus.SUCCESS(), res.getStatus());
- Mockito.when(dataSourceInfoService.existDataSource(dataSource.getDataSourceName())).thenReturn(true);
- mvcResult = mvcUtils.buildMvcResultPost("/data-source-manager/info/json",dsJsonWriter.toString());;
+ Mockito.when(dataSourceInfoService.existDataSource(dataSource.getDataSourceName()))
+ .thenReturn(true);
+ mvcResult =
+ mvcUtils.buildMvcResultPost(
+ "/data-source-manager/info/json", dsJsonWriter.toString());
+ ;
res = mvcUtils.getMessage(mvcResult);
assertEquals(MessageStatus.ERROR(), res.getStatus());
}
@@ -141,80 +152,116 @@ class DataSourceCoreRestfulApiTest {
void updateDataSourceInJson() throws Exception {
MvcUtils mvcUtils = new MvcUtils(mockMvc);
long dataSourceId = 1l;
- String url = String.format("/data-source-manager/info/%s/json",dataSourceId);
+ String url = String.format("/data-source-manager/info/%s/json", dataSourceId);
DataSource dataSource = new DataSource();
dataSource.setId(dataSourceId);
dataSource.setDataSourceName("ds-hive");
StringWriter dsJsonWriter = new StringWriter();
- JsonUtils.jackson().writeValue(dsJsonWriter,dataSource);
- securityFilter.when(()->SecurityFilter.getLoginUsername(isA(HttpServletRequest.class))).thenReturn("testUser");
- Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url,dsJsonWriter.toString()));
- assertTrue(MessageStatus.ERROR()==res.getStatus() && res.getMessage().contains("This data source was not found"));
+ JsonUtils.jackson().writeValue(dsJsonWriter, dataSource);
+ securityFilter
+ .when(() -> SecurityFilter.getLoginUsername(isA(HttpServletRequest.class)))
+ .thenReturn("testUser");
+ Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url, dsJsonWriter.toString()));
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("This data source was not found"));
DataSource oldDataSource = new DataSource();
oldDataSource.setCreateUser("hadoop");
- Mockito.when(dataSourceInfoService.getDataSourceInfoBrief(dataSource.getId())).thenReturn(oldDataSource);
- res = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url,dsJsonWriter.toString()));
- assertTrue(MessageStatus.ERROR()==res.getStatus() && res.getMessage().contains("Don't have update permission for data source"));
+ Mockito.when(dataSourceInfoService.getDataSourceInfoBrief(dataSource.getId()))
+ .thenReturn(oldDataSource);
+ res = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url, dsJsonWriter.toString()));
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage()
+ .contains("Don't have update permission for data source"));
oldDataSource.setCreateUser("testUser");
- res = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url,dsJsonWriter.toString()));
- assertTrue(MessageStatus.SUCCESS()==res.getStatus());
+ res = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url, dsJsonWriter.toString()));
+ assertTrue(MessageStatus.SUCCESS() == res.getStatus());
oldDataSource.setDataSourceName("ds-mysql");
- Mockito.when(dataSourceInfoService.existDataSource(dataSource.getDataSourceName())).thenReturn(true);
- res = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url,dsJsonWriter.toString()));
- assertTrue(MessageStatus.ERROR()==res.getStatus() && res.getMessage().contains("has been existed"));
-
-
+ Mockito.when(dataSourceInfoService.existDataSource(dataSource.getDataSourceName()))
+ .thenReturn(true);
+ res = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url, dsJsonWriter.toString()));
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("has been existed"));
}
@Test
void insertJsonParameter() throws Exception {
MvcUtils mvcUtils = new MvcUtils(mockMvc);
Long datasourceId = 1l;
- String url = String.format("/data-source-manager/parameter/%s/json",datasourceId);
- Map<String,Object> params = new HashMap<>();
+ String url = String.format("/data-source-manager/parameter/%s/json", datasourceId);
+ Map<String, Object> params = new HashMap<>();
Map<String, Object> connectParams = new HashMap<>();
- params.put("connectParams",connectParams);
- params.put("comment","comment");
+ params.put("connectParams", connectParams);
+ params.put("comment", "comment");
StringWriter dsJsonWriter = new StringWriter();
- JsonUtils.jackson().writeValue(dsJsonWriter,params);
+ JsonUtils.jackson().writeValue(dsJsonWriter, params);
- securityFilter.when(()->SecurityFilter.getLoginUsername(isA(HttpServletRequest.class))).thenReturn("testUser");
- Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultPost(url,dsJsonWriter.toString()));
- assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Fail to insert data source parameter"));
+ securityFilter
+ .when(() -> SecurityFilter.getLoginUsername(isA(HttpServletRequest.class)))
+ .thenReturn("testUser");
+ Message res =
+ mvcUtils.getMessage(mvcUtils.buildMvcResultPost(url, dsJsonWriter.toString()));
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Fail to insert data source parameter"));
DataSource dataSource = new DataSource();
dataSource.setCreateUser("hadoop");
- Mockito.when(dataSourceInfoService.getDataSourceInfoBrief(datasourceId)).thenReturn(dataSource);
- res = mvcUtils.getMessage(mvcUtils.buildMvcResultPost(url,dsJsonWriter.toString()));
- assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Don't have update permission"));
+ Mockito.when(dataSourceInfoService.getDataSourceInfoBrief(datasourceId))
+ .thenReturn(dataSource);
+ res = mvcUtils.getMessage(mvcUtils.buildMvcResultPost(url, dsJsonWriter.toString()));
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Don't have update permission"));
dataSource.setCreateUser("testUser");
List<DataSourceParamKeyDefinition> keyDefinitionList = new ArrayList<>();
- Mockito.when(dataSourceRelateService.getKeyDefinitionsByType(datasourceId)).thenReturn(keyDefinitionList);
- Mockito.when(dataSourceInfoService.insertDataSourceParameter(keyDefinitionList,datasourceId,connectParams,"testUser","comment")).thenReturn(10l);
- res = mvcUtils.getMessage(mvcUtils.buildMvcResultPost(url,dsJsonWriter.toString()));
- assertTrue(MessageStatus.SUCCESS() == res.getStatus() && "10".equals(res.getData().get("version").toString()));
+ Mockito.when(dataSourceRelateService.getKeyDefinitionsByType(datasourceId))
+ .thenReturn(keyDefinitionList);
+ Mockito.when(
+ dataSourceInfoService.insertDataSourceParameter(
+ keyDefinitionList,
+ datasourceId,
+ connectParams,
+ "testUser",
+ "comment"))
+ .thenReturn(10l);
+ res = mvcUtils.getMessage(mvcUtils.buildMvcResultPost(url, dsJsonWriter.toString()));
+ assertTrue(
+ MessageStatus.SUCCESS() == res.getStatus()
+ && "10".equals(res.getData().get("version").toString()));
}
@Test
void getInfoByDataSourceId() throws Exception {
MvcUtils mvcUtils = new MvcUtils(mockMvc);
Long dataSourceId = 1l;
- String url = String.format("/data-source-manager/info/%s",dataSourceId);
+ String url = String.format("/data-source-manager/info/%s", dataSourceId);
DataSource dataSource = new DataSource();
dataSource.setId(dataSourceId);
dataSource.setCreateUser("hadoop");
- Mockito.when(dataSourceInfoService.getDataSourceInfo(dataSourceId)).thenReturn(null).thenReturn(dataSource);
+ Mockito.when(dataSourceInfoService.getDataSourceInfo(dataSourceId))
+ .thenReturn(null)
+ .thenReturn(dataSource);
Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
- assertTrue(MessageStatus.ERROR()==res.getStatus() && res.getMessage().contains("No Exists The DataSource"));
-
- securityFilter.when(()->SecurityFilter.getLoginUsername(isA(HttpServletRequest.class))).thenReturn("testUser").thenReturn("hadoop");
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("No Exists The DataSource"));
+
+ securityFilter
+ .when(() -> SecurityFilter.getLoginUsername(isA(HttpServletRequest.class)))
+ .thenReturn("testUser")
+ .thenReturn("hadoop");
res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
- assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Don't have query permission"));
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Don't have query permission"));
res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
assertTrue(MessageStatus.SUCCESS() == res.getStatus());
@@ -224,17 +271,26 @@ class DataSourceCoreRestfulApiTest {
void getInfoByDataSourceName() throws Exception {
MvcUtils mvcUtils = new MvcUtils(mockMvc);
String dataSourceName = "hive-test";
- String url = String.format("/data-source-manager/info/name/%s",dataSourceName);
+ String url = String.format("/data-source-manager/info/name/%s", dataSourceName);
DataSource dataSource = new DataSource();
dataSource.setDataSourceName(dataSourceName);
dataSource.setCreateUser("hadoop");
- Mockito.when(dataSourceInfoService.getDataSourceInfo(dataSourceName)).thenReturn(null).thenReturn(dataSource);
+ Mockito.when(dataSourceInfoService.getDataSourceInfo(dataSourceName))
+ .thenReturn(null)
+ .thenReturn(dataSource);
Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
- assertTrue(MessageStatus.ERROR()==res.getStatus() && res.getMessage().contains("No Exists The DataSource"));
-
- securityFilter.when(()->SecurityFilter.getLoginUsername(isA(HttpServletRequest.class))).thenReturn("testUser").thenReturn("hadoop");
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("No Exists The DataSource"));
+
+ securityFilter
+ .when(() -> SecurityFilter.getLoginUsername(isA(HttpServletRequest.class)))
+ .thenReturn("testUser")
+ .thenReturn("hadoop");
res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
- assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Don't have query permission"));
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Don't have query permission"));
res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
assertTrue(MessageStatus.SUCCESS() == res.getStatus());
@@ -245,18 +301,27 @@ class DataSourceCoreRestfulApiTest {
MvcUtils mvcUtils = new MvcUtils(mockMvc);
long dataSourceId = 1l;
long version = 1001l;
- String url = String.format("/data-source-manager/info/%s/%s",dataSourceId,version);
+ String url = String.format("/data-source-manager/info/%s/%s", dataSourceId, version);
DataSource dataSource = new DataSource();
dataSource.setId(dataSourceId);
dataSource.setVersionId(version);
dataSource.setCreateUser("hadoop");
- Mockito.when(dataSourceInfoService.getDataSourceInfo(dataSourceId,version)).thenReturn(null).thenReturn(dataSource);
+ Mockito.when(dataSourceInfoService.getDataSourceInfo(dataSourceId, version))
+ .thenReturn(null)
+ .thenReturn(dataSource);
Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
- assertTrue(MessageStatus.ERROR()==res.getStatus() && res.getMessage().contains("No Exists The DataSource"));
-
- securityFilter.when(()->SecurityFilter.getLoginUsername(isA(HttpServletRequest.class))).thenReturn("testUser").thenReturn("hadoop");
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("No Exists The DataSource"));
+
+ securityFilter
+ .when(() -> SecurityFilter.getLoginUsername(isA(HttpServletRequest.class)))
+ .thenReturn("testUser")
+ .thenReturn("hadoop");
res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
- assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Don't have query permission"));
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Don't have query permission"));
res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
assertTrue(MessageStatus.SUCCESS() == res.getStatus());
@@ -266,17 +331,26 @@ class DataSourceCoreRestfulApiTest {
void getVersionList() throws Exception {
MvcUtils mvcUtils = new MvcUtils(mockMvc);
long dataSourceId = 1l;
- String url = String.format("/data-source-manager/%s/versions",dataSourceId);
+ String url = String.format("/data-source-manager/%s/versions", dataSourceId);
DataSource dataSource = new DataSource();
dataSource.setId(dataSourceId);
dataSource.setCreateUser("hadoop");
- Mockito.when(dataSourceInfoService.getDataSourceInfoBrief(dataSourceId)).thenReturn(null).thenReturn(dataSource);
+ Mockito.when(dataSourceInfoService.getDataSourceInfoBrief(dataSourceId))
+ .thenReturn(null)
+ .thenReturn(dataSource);
Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
- assertTrue(MessageStatus.ERROR()==res.getStatus() && res.getMessage().contains("No Exists The DataSource"));
-
- securityFilter.when(()->SecurityFilter.getLoginUsername(isA(HttpServletRequest.class))).thenReturn("testUser").thenReturn("hadoop");
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("No Exists The DataSource"));
+
+ securityFilter
+ .when(() -> SecurityFilter.getLoginUsername(isA(HttpServletRequest.class)))
+ .thenReturn("testUser")
+ .thenReturn("hadoop");
res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
- assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Don't have query permission"));
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Don't have query permission"));
res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
assertTrue(MessageStatus.SUCCESS() == res.getStatus());
@@ -287,47 +361,72 @@ class DataSourceCoreRestfulApiTest {
MvcUtils mvcUtils = new MvcUtils(mockMvc);
long dataSourceId = 1l;
long version = 1001l;
- String url = String.format("/data-source-manager/publish/%s/%s",dataSourceId,version);
+ String url = String.format("/data-source-manager/publish/%s/%s", dataSourceId, version);
DataSource dataSource = new DataSource();
dataSource.setId(dataSourceId);
dataSource.setVersionId(version);
dataSource.setCreateUser("hadoop");
- Mockito.when(dataSourceInfoService.getDataSourceInfoBrief(dataSourceId)).thenReturn(null).thenReturn(dataSource);
+ Mockito.when(dataSourceInfoService.getDataSourceInfoBrief(dataSourceId))
+ .thenReturn(null)
+ .thenReturn(dataSource);
Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultPost(url));
- assertTrue(MessageStatus.ERROR()==res.getStatus() && res.getMessage().contains("No Exists The DataSource"));
-
- securityFilter.when(()->SecurityFilter.getLoginUsername(isA(HttpServletRequest.class))).thenReturn("testUser").thenReturn("hadoop");
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("No Exists The DataSource"));
+
+ securityFilter
+ .when(() -> SecurityFilter.getLoginUsername(isA(HttpServletRequest.class)))
+ .thenReturn("testUser")
+ .thenReturn("hadoop");
res = mvcUtils.getMessage(mvcUtils.buildMvcResultPost(url));
- assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Don't have publish permission"));
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Don't have publish permission"));
- Mockito.when(dataSourceInfoService.publishByDataSourceId(dataSourceId,version)).thenReturn(0).thenReturn(1);
+ Mockito.when(dataSourceInfoService.publishByDataSourceId(dataSourceId, version))
+ .thenReturn(0)
+ .thenReturn(1);
res = mvcUtils.getMessage(mvcUtils.buildMvcResultPost(url));
- assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("publish error"));
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("publish error"));
res = mvcUtils.getMessage(mvcUtils.buildMvcResultPost(url));
assertTrue(MessageStatus.SUCCESS() == res.getStatus());
-
}
@Test
void removeDataSource() throws Exception {
MvcUtils mvcUtils = new MvcUtils(mockMvc);
long dataSourceId = 1l;
- String url = String.format("/data-source-manager/info/%s",dataSourceId);
+ String url = String.format("/data-source-manager/info/%s", dataSourceId);
DataSource dataSource = new DataSource();
dataSource.setId(dataSourceId);
dataSource.setCreateUser("hadoop");
- Mockito.when(dataSourceInfoService.getDataSourceInfoBrief(dataSourceId)).thenReturn(null).thenReturn(dataSource);
+ Mockito.when(dataSourceInfoService.getDataSourceInfoBrief(dataSourceId))
+ .thenReturn(null)
+ .thenReturn(dataSource);
Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultDelete(url));
- assertTrue(MessageStatus.ERROR()==res.getStatus() && res.getMessage().contains("No Exists The DataSource"));
-
- securityFilter.when(()->SecurityFilter.getLoginUsername(isA(HttpServletRequest.class))).thenReturn("testUser").thenReturn("hadoop");
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("No Exists The DataSource"));
+
+ securityFilter
+ .when(() -> SecurityFilter.getLoginUsername(isA(HttpServletRequest.class)))
+ .thenReturn("testUser")
+ .thenReturn("hadoop");
res = mvcUtils.getMessage(mvcUtils.buildMvcResultDelete(url));
- assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Don't have delete permission"));
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Don't have delete permission"));
- Mockito.when(dataSourceInfoService.removeDataSourceInfo(dataSourceId,"")).thenReturn(-1l).thenReturn(1l);
+ Mockito.when(dataSourceInfoService.removeDataSourceInfo(dataSourceId, ""))
+ .thenReturn(-1l)
+ .thenReturn(1l);
res = mvcUtils.getMessage(mvcUtils.buildMvcResultDelete(url));
- assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Fail to remove data source"));
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Fail to remove data source"));
res = mvcUtils.getMessage(mvcUtils.buildMvcResultDelete(url));
assertTrue(MessageStatus.SUCCESS() == res.getStatus());
@@ -337,21 +436,34 @@ class DataSourceCoreRestfulApiTest {
void expireDataSource() throws Exception {
MvcUtils mvcUtils = new MvcUtils(mockMvc);
long dataSourceId = 1l;
- String url = String.format("/data-source-manager/info/%s/expire",dataSourceId);
+ String url = String.format("/data-source-manager/info/%s/expire", dataSourceId);
DataSource dataSource = new DataSource();
dataSource.setId(dataSourceId);
dataSource.setCreateUser("hadoop");
- Mockito.when(dataSourceInfoService.getDataSourceInfoBrief(dataSourceId)).thenReturn(null).thenReturn(dataSource);
+ Mockito.when(dataSourceInfoService.getDataSourceInfoBrief(dataSourceId))
+ .thenReturn(null)
+ .thenReturn(dataSource);
Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url));
- assertTrue(MessageStatus.ERROR()==res.getStatus() && res.getMessage().contains("No Exists The DataSource"));
-
- securityFilter.when(()->SecurityFilter.getLoginUsername(isA(HttpServletRequest.class))).thenReturn("testUser").thenReturn("hadoop");
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("No Exists The DataSource"));
+
+ securityFilter
+ .when(() -> SecurityFilter.getLoginUsername(isA(HttpServletRequest.class)))
+ .thenReturn("testUser")
+ .thenReturn("hadoop");
res = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url));
- assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Don't have operation permission"));
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Don't have operation permission"));
- Mockito.when(dataSourceInfoService.expireDataSource(dataSourceId)).thenReturn(-1l).thenReturn(1l);
+ Mockito.when(dataSourceInfoService.expireDataSource(dataSourceId))
+ .thenReturn(-1l)
+ .thenReturn(1l);
res = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url));
- assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Fail to expire data source"));
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Fail to expire data source"));
res = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url));
assertTrue(MessageStatus.SUCCESS() == res.getStatus());
@@ -361,17 +473,26 @@ class DataSourceCoreRestfulApiTest {
void testGetConnectParamsById() throws Exception {
MvcUtils mvcUtils = new MvcUtils(mockMvc);
long dataSourceId = 1l;
- String url = String.format("/data-source-manager/%s/connect_params",dataSourceId);
+ String url = String.format("/data-source-manager/%s/connect_params", dataSourceId);
DataSource dataSource = new DataSource();
dataSource.setId(dataSourceId);
dataSource.setCreateUser("hadoop");
- Mockito.when(dataSourceInfoService.getDataSourceInfoForConnect(dataSourceId)).thenReturn(null).thenReturn(dataSource);
+ Mockito.when(dataSourceInfoService.getDataSourceInfoForConnect(dataSourceId))
+ .thenReturn(null)
+ .thenReturn(dataSource);
Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
- assertTrue(MessageStatus.ERROR()==res.getStatus() && res.getMessage().contains("No Exists The DataSource"));
-
- securityFilter.when(()->SecurityFilter.getLoginUsername(isA(HttpServletRequest.class))).thenReturn("testUser").thenReturn("hadoop");
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("No Exists The DataSource"));
+
+ securityFilter
+ .when(() -> SecurityFilter.getLoginUsername(isA(HttpServletRequest.class)))
+ .thenReturn("testUser")
+ .thenReturn("hadoop");
res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
- assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Don't have query permission"));
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Don't have query permission"));
res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
assertTrue(MessageStatus.SUCCESS() == res.getStatus());
@@ -381,17 +502,26 @@ class DataSourceCoreRestfulApiTest {
void testGetConnectParamsByName() throws Exception {
MvcUtils mvcUtils = new MvcUtils(mockMvc);
String dataSourceName = "hive-test";
- String url = String.format("/data-source-manager/name/%s/connect_params",dataSourceName);
+ String url = String.format("/data-source-manager/name/%s/connect_params", dataSourceName);
DataSource dataSource = new DataSource();
dataSource.setDataSourceName(dataSourceName);
dataSource.setCreateUser("hadoop");
- Mockito.when(dataSourceInfoService.getDataSourceInfoForConnect(dataSourceName)).thenReturn(null).thenReturn(dataSource);
+ Mockito.when(dataSourceInfoService.getDataSourceInfoForConnect(dataSourceName))
+ .thenReturn(null)
+ .thenReturn(dataSource);
Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
- assertTrue(MessageStatus.ERROR()==res.getStatus() && res.getMessage().contains("No Exists The DataSource"));
-
- securityFilter.when(()->SecurityFilter.getLoginUsername(isA(HttpServletRequest.class))).thenReturn("testUser").thenReturn("hadoop");
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("No Exists The DataSource"));
+
+ securityFilter
+ .when(() -> SecurityFilter.getLoginUsername(isA(HttpServletRequest.class)))
+ .thenReturn("testUser")
+ .thenReturn("hadoop");
res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
- assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Don't have query permission"));
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Don't have query permission"));
res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url));
assertTrue(MessageStatus.SUCCESS() == res.getStatus());
@@ -402,7 +532,7 @@ class DataSourceCoreRestfulApiTest {
MvcUtils mvcUtils = new MvcUtils(mockMvc);
long dataSourceId = 1l;
long version = 1001l;
- String url = String.format("/data-source-manager/%s/%s/op/connect",dataSourceId,version);
+ String url = String.format("/data-source-manager/%s/%s/op/connect", dataSourceId, version);
DataSource dataSource = new DataSource();
dataSource.setId(dataSourceId);
dataSource.setVersionId(version);
@@ -410,34 +540,51 @@ class DataSourceCoreRestfulApiTest {
DataSourceType dataSourceType = new DataSourceType();
dataSourceType.setName("hive");
dataSource.setDataSourceType(dataSourceType);
- securityFilter.when(()->SecurityFilter.getLoginUsername(isA(HttpServletRequest.class))).thenReturn("testUser","testUser","testUser","hadoop");
- Mockito.when(dataSourceInfoService.getDataSourceInfoForConnect(dataSourceId,version)).thenReturn(null).thenReturn(dataSource);
+ securityFilter
+ .when(() -> SecurityFilter.getLoginUsername(isA(HttpServletRequest.class)))
+ .thenReturn("testUser", "testUser", "testUser", "hadoop");
+ Mockito.when(dataSourceInfoService.getDataSourceInfoForConnect(dataSourceId, version))
+ .thenReturn(null)
+ .thenReturn(dataSource);
Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url));
- assertTrue(MessageStatus.ERROR()==res.getStatus() && res.getMessage().contains("No Exists The DataSource"));
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("No Exists The DataSource"));
res = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url));
- assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Don't have operation permission"));
-
- Mockito.doNothing().when(metadataOperateService).doRemoteConnect("metadata-manager",dataSourceType.getName(),"hadoop",new HashMap<String,Object>());
+ assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Don't have operation permission"));
+
+ Mockito.doNothing()
+ .when(metadataOperateService)
+ .doRemoteConnect(
+ "metadata-manager",
+ dataSourceType.getName(),
+ "hadoop",
+ new HashMap<String, Object>());
res = mvcUtils.getMessage(mvcUtils.buildMvcResultPut(url));
- assertTrue(MessageStatus.SUCCESS() == res.getStatus() );
+ assertTrue(MessageStatus.SUCCESS() == res.getStatus());
}
@Test
void queryDataSource() throws Exception {
MvcUtils mvcUtils = new MvcUtils(mockMvc);
String url = String.format("/data-source-manager/info");
- MultiValueMap<String,String> params = new LinkedMultiValueMap<>();
- params.add("currentPage","10");
- params.add("pageSize","20");
- securityFilter.when(()->SecurityFilter.getLoginUsername(isA(HttpServletRequest.class))).thenReturn("testUser");
+ MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
+ params.add("currentPage", "10");
+ params.add("pageSize", "20");
+ securityFilter
+ .when(() -> SecurityFilter.getLoginUsername(isA(HttpServletRequest.class)))
+ .thenReturn("testUser");
DataSourceVo dataSourceVo = new DataSourceVo();
PageInfo<DataSource> pageInfo = new PageInfo<>();
pageInfo.setTotal(10l);
Mockito.when(dataSourceInfoService.queryDataSourceInfoPage(any())).thenReturn(pageInfo);
- Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url,params));
- assertTrue(MessageStatus.SUCCESS() == res.getStatus() && "10".equals(res.getData().get("totalPage").toString()));
-
+ Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url, params));
+ assertTrue(
+ MessageStatus.SUCCESS() == res.getStatus()
+ && "10".equals(res.getData().get("totalPage").toString()));
}
-}
\ No newline at end of file
+}
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/restful/DataSourceOperateRestfulApiTest.java b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/restful/DataSourceOperateRestfulApiTest.java
index d8e570d..af1d605 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/restful/DataSourceOperateRestfulApiTest.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/restful/DataSourceOperateRestfulApiTest.java
@@ -19,14 +19,16 @@ package org.apache.linkis.datasourcemanager.core.restful;
import org.apache.linkis.datasourcemanager.core.Scan;
import org.apache.linkis.datasourcemanager.core.WebApplicationServer;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
+
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.web.servlet.MockMvc;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
import static org.junit.jupiter.api.Assertions.*;
@ExtendWith({SpringExtension.class})
@@ -34,14 +36,11 @@ import static org.junit.jupiter.api.Assertions.*;
@SpringBootTest(classes = {WebApplicationServer.class, Scan.class})
class DataSourceOperateRestfulApiTest {
- @Autowired
- protected MockMvc mockMvc;
+ @Autowired protected MockMvc mockMvc;
@Test
- void connect() {
- }
+ void connect() {}
@Test
- void doConnect() {
- }
-}
\ No newline at end of file
+ void doConnect() {}
+}
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/restful/MvcUtils.java b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/restful/MvcUtils.java
index ab834e3..bca2b2b 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/restful/MvcUtils.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/restful/MvcUtils.java
@@ -19,6 +19,7 @@ package org.apache.linkis.datasourcemanager.core.restful;
import org.apache.linkis.common.utils.JsonUtils;
import org.apache.linkis.server.Message;
+
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
@@ -45,7 +46,8 @@ public class MvcUtils {
return mvcResult;
}
- public MvcResult buildMvcResultGet(String url, MultiValueMap<String,String> params) throws Exception {
+ public MvcResult buildMvcResultGet(String url, MultiValueMap<String, String> params)
+ throws Exception {
MvcResult mvcResult =
mockMvc.perform(get(url).params(params))
.andExpect(status().isOk())
@@ -54,7 +56,7 @@ public class MvcUtils {
return mvcResult;
}
- public MvcResult buildMvcResultPost(String url,String json) throws Exception {
+ public MvcResult buildMvcResultPost(String url, String json) throws Exception {
MvcResult mvcResult =
mockMvc.perform(post(url).contentType(MediaType.APPLICATION_JSON).content(json))
.andExpect(status().isOk())
@@ -62,6 +64,7 @@ public class MvcUtils {
.andReturn();
return mvcResult;
}
+
public MvcResult buildMvcResultPost(String url) throws Exception {
MvcResult mvcResult =
mockMvc.perform(post(url))
@@ -79,6 +82,7 @@ public class MvcUtils {
.andReturn();
return mvcResult;
}
+
public MvcResult buildMvcResultPut(String url) throws Exception {
MvcResult mvcResult =
mockMvc.perform(put(url))
@@ -103,5 +107,4 @@ public class MvcUtils {
.readValue(mvcResult.getResponse().getContentAsString(), Message.class);
return res;
}
-
}
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/service/BmlAppServiceTest.java b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/service/BmlAppServiceTest.java
index 84cea51..32f2f40 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/service/BmlAppServiceTest.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/service/BmlAppServiceTest.java
@@ -23,6 +23,7 @@ import org.apache.linkis.bml.protocol.BmlUpdateResponse;
import org.apache.linkis.bml.protocol.BmlUploadResponse;
import org.apache.linkis.common.exception.ErrorException;
import org.apache.linkis.datasourcemanager.core.service.impl.BmlAppServiceImpl;
+
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
@@ -47,22 +48,23 @@ public class BmlAppServiceTest {
@Test
void testClientUploadResource() throws ErrorException {
InputStream inputStream = Mockito.mock(FileInputStream.class);
- BmlUploadResponse bmlUploadResponse = new BmlUploadResponse(true,"10001","1");
- Mockito.when(client.uploadResource("test", "/test/a.txt", inputStream)).thenReturn(bmlUploadResponse);
+ BmlUploadResponse bmlUploadResponse = new BmlUploadResponse(true, "10001", "1");
+ Mockito.when(client.uploadResource("test", "/test/a.txt", inputStream))
+ .thenReturn(bmlUploadResponse);
String res = bmlAppService.clientUploadResource("test", "/test/a.txt", inputStream);
assertTrue(res.equals("10001"));
}
@Test
- void testClientRemoveResource(){
+ void testClientRemoveResource() {
String user = "test";
String resourceId = "10001";
BmlDeleteResponse bmlDeleteResponse = new BmlDeleteResponse(true);
Mockito.when(client.deleteResource(user, resourceId)).thenReturn(bmlDeleteResponse);
try {
- bmlAppService.clientRemoveResource(user,resourceId);
+ bmlAppService.clientRemoveResource(user, resourceId);
} catch (ErrorException e) {
- logger.error("bmlAppService clientRemoveResource error:"+e.getMessage());
+ logger.error("bmlAppService clientRemoveResource error:" + e.getMessage());
}
}
@@ -72,8 +74,9 @@ public class BmlAppServiceTest {
String resourceId = "10001";
String version = "2";
InputStream inputStream = Mockito.mock(FileInputStream.class);
- BmlUpdateResponse bmlUpdateResponse = new BmlUpdateResponse(true,resourceId,version);
- Mockito.when(client.updateResource(userName, resourceId, "filename",inputStream)).thenReturn(bmlUpdateResponse);
+ BmlUpdateResponse bmlUpdateResponse = new BmlUpdateResponse(true, resourceId, version);
+ Mockito.when(client.updateResource(userName, resourceId, "filename", inputStream))
+ .thenReturn(bmlUpdateResponse);
String res = bmlAppService.clientUpdateResource(userName, resourceId, inputStream);
assertTrue(version.equals(res));
}
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/service/DataSourceInfoServiceTest.java b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/service/DataSourceInfoServiceTest.java
index 3b091e8..c2608f6 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/service/DataSourceInfoServiceTest.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/service/DataSourceInfoServiceTest.java
@@ -17,7 +17,6 @@
package org.apache.linkis.datasourcemanager.core.service;
-import com.github.pagehelper.PageInfo;
import org.apache.linkis.common.exception.ErrorException;
import org.apache.linkis.datasourcemanager.common.domain.DataSource;
import org.apache.linkis.datasourcemanager.common.domain.DataSourceEnv;
@@ -25,7 +24,8 @@ import org.apache.linkis.datasourcemanager.common.domain.DataSourceParamKeyDefin
import org.apache.linkis.datasourcemanager.core.dao.*;
import org.apache.linkis.datasourcemanager.core.service.impl.DataSourceInfoServiceImpl;
import org.apache.linkis.datasourcemanager.core.vo.DataSourceVo;
-import org.junit.jupiter.api.Assertions;
+
+import com.github.pagehelper.PageInfo;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
@@ -38,32 +38,24 @@ import org.slf4j.LoggerFactory;
import java.util.*;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.hamcrest.core.Is.is;
-import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
@ExtendWith(MockitoExtension.class)
public class DataSourceInfoServiceTest {
private static final Logger logger = LoggerFactory.getLogger(DataSourceInfoServiceTest.class);
- @InjectMocks
- DataSourceInfoServiceImpl dataSourceInfoService;
+ @InjectMocks DataSourceInfoServiceImpl dataSourceInfoService;
- @Mock
- DataSourceDao dataSourceDao;
+ @Mock DataSourceDao dataSourceDao;
- @Mock
- DataSourceEnvDao dataSourceEnvDao;
+ @Mock DataSourceEnvDao dataSourceEnvDao;
- @Mock
- DataSourceVersionDao dataSourceVersionDao;
+ @Mock DataSourceVersionDao dataSourceVersionDao;
- @Mock
- DataSourceTypeEnvDao dataSourceTypeEnvDao;
+ @Mock DataSourceTypeEnvDao dataSourceTypeEnvDao;
- @Mock
- DataSourceParamKeyDao dataSourceParamKeyDao;
+ @Mock DataSourceParamKeyDao dataSourceParamKeyDao;
- private DataSource buildDataSource(){
+ private DataSource buildDataSource() {
DataSource dataSource = new DataSource();
dataSource.setId(1l);
dataSource.setDataSourceName("unitTest");
@@ -86,129 +78,171 @@ public class DataSourceInfoServiceTest {
DataSource dataSource = buildDataSource();
Mockito.doNothing().when(dataSourceDao).insertOne(dataSource);
dataSourceInfoService.saveDataSourceInfo(dataSource);
- Mockito.verify(dataSourceDao,Mockito.times(1)).insertOne(dataSource);
+ Mockito.verify(dataSourceDao, Mockito.times(1)).insertOne(dataSource);
}
@Test
- void testAddEnvParamsToDataSource(){
+ void testAddEnvParamsToDataSource() {
DataSource dataSource = buildDataSource();
Map<String, Object> envParamMap = new HashMap<>();
- envParamMap.put("a","b");
+ envParamMap.put("a", "b");
dataSource.setConnectParams(envParamMap);
Long dataSourceEnvId = 1l;
DataSourceEnv dataSourceEnv = new DataSourceEnv();
Map<String, Object> envAllParamMap = new HashMap<>();
- envAllParamMap.put("c","d");
+ envAllParamMap.put("c", "d");
dataSourceEnv.setConnectParams(envAllParamMap);
envAllParamMap.putAll(envAllParamMap);
Mockito.when(dataSourceEnvDao.selectOneDetail(dataSourceEnvId)).thenReturn(dataSourceEnv);
- dataSourceInfoService.addEnvParamsToDataSource(dataSourceEnvId,dataSource);
+ dataSourceInfoService.addEnvParamsToDataSource(dataSourceEnvId, dataSource);
assertTrue(envAllParamMap.equals(dataSource.getConnectParams()));
}
@Test
- void testGetDataSourceInfo(){
+ void testGetDataSourceInfo() {
DataSource dataSource = buildDataSource();
Mockito.when(dataSourceDao.selectOneDetail(dataSource.getId())).thenReturn(dataSource);
- Mockito.when(dataSourceVersionDao.selectOneVersion(dataSource.getId(),dataSource.getVersionId())).thenReturn("a:b");
+ Mockito.when(
+ dataSourceVersionDao.selectOneVersion(
+ dataSource.getId(), dataSource.getVersionId()))
+ .thenReturn("a:b");
dataSource.setParameter("a:b");
- DataSource actuallyDataSource= dataSourceInfoService.getDataSourceInfo(dataSource.getId());
+ DataSource actuallyDataSource = dataSourceInfoService.getDataSourceInfo(dataSource.getId());
assertThat(actuallyDataSource).usingRecursiveComparison().isEqualTo(dataSource);
}
@Test
- void testGetDataSourceInfoByName(){
+ void testGetDataSourceInfoByName() {
DataSource dataSource = buildDataSource();
- Mockito.when(dataSourceDao.selectOneDetailByName(dataSource.getDataSourceName())).thenReturn(dataSource);
- Mockito.when(dataSourceVersionDao.selectOneVersion(dataSource.getId(),dataSource.getVersionId())).thenReturn("a:b");
+ Mockito.when(dataSourceDao.selectOneDetailByName(dataSource.getDataSourceName()))
+ .thenReturn(dataSource);
+ Mockito.when(
+ dataSourceVersionDao.selectOneVersion(
+ dataSource.getId(), dataSource.getVersionId()))
+ .thenReturn("a:b");
dataSource.setParameter("a:b");
- DataSource actuallyDataSource= dataSourceInfoService.getDataSourceInfo(dataSource.getDataSourceName());
+ DataSource actuallyDataSource =
+ dataSourceInfoService.getDataSourceInfo(dataSource.getDataSourceName());
assertThat(actuallyDataSource).usingRecursiveComparison().isEqualTo(dataSource);
}
@Test
- void testGetDataSourceInfoByIdAndVerId(){
+ void testGetDataSourceInfoByIdAndVerId() {
DataSource dataSource = buildDataSource();
Mockito.when(dataSourceDao.selectOneDetail(dataSource.getId())).thenReturn(dataSource);
- Mockito.when(dataSourceVersionDao.selectOneVersion(dataSource.getId(),dataSource.getVersionId())).thenReturn("a:b");
+ Mockito.when(
+ dataSourceVersionDao.selectOneVersion(
+ dataSource.getId(), dataSource.getVersionId()))
+ .thenReturn("a:b");
dataSource.setParameter("a:b");
- DataSource actuallyDataSource= dataSourceInfoService.getDataSourceInfo(dataSource.getId(),dataSource.getVersionId());
+ DataSource actuallyDataSource =
+ dataSourceInfoService.getDataSourceInfo(
+ dataSource.getId(), dataSource.getVersionId());
assertThat(actuallyDataSource).usingRecursiveComparison().isEqualTo(dataSource);
}
-
@Test
- void testGetDataSourceInfoForConnectById(){
+ void testGetDataSourceInfoForConnectById() {
DataSource dataSource = buildDataSource();
Mockito.when(dataSourceDao.selectOneDetail(dataSource.getId())).thenReturn(dataSource);
- Mockito.when(dataSourceVersionDao.selectOneVersion(dataSource.getId(),dataSource.getPublishedVersionId())).thenReturn("{\"a\":\"b\"}");
- String res = dataSourceInfoService.getDataSourceInfoForConnect(dataSource.getId()).getConnectParams().toString();
+ Mockito.when(
+ dataSourceVersionDao.selectOneVersion(
+ dataSource.getId(), dataSource.getPublishedVersionId()))
+ .thenReturn("{\"a\":\"b\"}");
+ String res =
+ dataSourceInfoService
+ .getDataSourceInfoForConnect(dataSource.getId())
+ .getConnectParams()
+ .toString();
assertTrue("{a=b}".equals(res));
- Mockito.verify(dataSourceDao,Mockito.times(1)).selectOneDetail(dataSource.getId());
+ Mockito.verify(dataSourceDao, Mockito.times(1)).selectOneDetail(dataSource.getId());
}
@Test
- void testGetDataSourceInfoForConnectByName(){
+ void testGetDataSourceInfoForConnectByName() {
DataSource dataSource = buildDataSource();
- Mockito.when(dataSourceDao.selectOneDetailByName(dataSource.getDataSourceName())).thenReturn(dataSource);
- Mockito.when(dataSourceVersionDao.selectOneVersion(dataSource.getId(),dataSource.getPublishedVersionId())).thenReturn("{\"a\":\"b\"}");
- String res = dataSourceInfoService.getDataSourceInfoForConnect(dataSource.getDataSourceName()).getConnectParams().toString();
+ Mockito.when(dataSourceDao.selectOneDetailByName(dataSource.getDataSourceName()))
+ .thenReturn(dataSource);
+ Mockito.when(
+ dataSourceVersionDao.selectOneVersion(
+ dataSource.getId(), dataSource.getPublishedVersionId()))
+ .thenReturn("{\"a\":\"b\"}");
+ String res =
+ dataSourceInfoService
+ .getDataSourceInfoForConnect(dataSource.getDataSourceName())
+ .getConnectParams()
+ .toString();
assertTrue("{a=b}".equals(res));
}
@Test
- void testGetDataSourceInfoForConnectByIdAndVerId(){
+ void testGetDataSourceInfoForConnectByIdAndVerId() {
DataSource dataSource = buildDataSource();
Mockito.when(dataSourceDao.selectOneDetail(dataSource.getId())).thenReturn(dataSource);
- Mockito.when(dataSourceVersionDao.selectOneVersion(dataSource.getId(),dataSource.getVersionId())).thenReturn("{\"a\":\"b\"}");
- String res = dataSourceInfoService.getDataSourceInfoForConnect(dataSource.getId(),dataSource.getVersionId()).getConnectParams().toString();
+ Mockito.when(
+ dataSourceVersionDao.selectOneVersion(
+ dataSource.getId(), dataSource.getVersionId()))
+ .thenReturn("{\"a\":\"b\"}");
+ String res =
+ dataSourceInfoService
+ .getDataSourceInfoForConnect(dataSource.getId(), dataSource.getVersionId())
+ .getConnectParams()
+ .toString();
assertTrue("{a=b}".equals(res));
}
@Test
- void testExistDataSource(){
+ void testExistDataSource() {
String dataSourceName = "unitTest";
DataSource dataSource = buildDataSource();
Mockito.when(dataSourceDao.selectOneByName(dataSourceName)).thenReturn(dataSource);
assertTrue(dataSourceInfoService.existDataSource(dataSourceName));
-
}
-
@Test
- void testGetDataSourceInfoBrief(){
+ void testGetDataSourceInfoBrief() {
DataSource dataSource = buildDataSource();
Mockito.when(dataSourceDao.selectOne(dataSource.getId())).thenReturn(dataSource);
- assertThat(dataSourceInfoService.getDataSourceInfoBrief(dataSource.getId())).usingRecursiveComparison().isEqualTo(dataSource);
+ assertThat(dataSourceInfoService.getDataSourceInfoBrief(dataSource.getId()))
+ .usingRecursiveComparison()
+ .isEqualTo(dataSource);
}
@Test
- void testRemoveDataSourceInfo(){
+ void testRemoveDataSourceInfo() {
DataSource dataSource = buildDataSource();
- Mockito.when(dataSourceDao.selectOne(dataSource.getId())).thenReturn(dataSource).thenReturn(null);
+ Mockito.when(dataSourceDao.selectOne(dataSource.getId()))
+ .thenReturn(dataSource)
+ .thenReturn(null);
Mockito.when(dataSourceDao.removeOne(dataSource.getId())).thenReturn(1);
- assertTrue(dataSourceInfoService.removeDataSourceInfo(dataSource.getId(),dataSource.getCreateSystem())>0);
- assertTrue(dataSourceInfoService.removeDataSourceInfo(dataSource.getId(),dataSource.getCreateSystem())==-1);
+ assertTrue(
+ dataSourceInfoService.removeDataSourceInfo(
+ dataSource.getId(), dataSource.getCreateSystem())
+ > 0);
+ assertTrue(
+ dataSourceInfoService.removeDataSourceInfo(
+ dataSource.getId(), dataSource.getCreateSystem())
+ == -1);
}
-
@Test
- void testUpdateDataSourceInfo(){
+ void testUpdateDataSourceInfo() {
DataSource dataSource = buildDataSource();
dataSourceInfoService.updateDataSourceInfo(dataSource);
}
@Test
- void testQueryDataSourceInfoPage(){
+ void testQueryDataSourceInfoPage() {
DataSourceVo dataSourceVo = new DataSourceVo();
dataSourceVo.setPageSize(10);
dataSourceVo.setCurrentPage(1);
- List<DataSource> dataSources= new ArrayList<>();
+ List<DataSource> dataSources = new ArrayList<>();
dataSources.add(buildDataSource());
dataSources.add(buildDataSource());
Mockito.when(dataSourceDao.selectByPageVo(dataSourceVo)).thenReturn(dataSources);
- PageInfo<DataSource> dataSourcePageInfo = dataSourceInfoService.queryDataSourceInfoPage(dataSourceVo);
+ PageInfo<DataSource> dataSourcePageInfo =
+ dataSourceInfoService.queryDataSourceInfoPage(dataSourceVo);
assertTrue(dataSourcePageInfo.getSize() == 2);
}
@@ -223,16 +257,18 @@ public class DataSourceInfoServiceTest {
}
@Test
- void testListDataSourceEnvByType(){
+ void testListDataSourceEnvByType() {
List<DataSourceEnv> dataSourceEnvs = new ArrayList<>();
dataSourceEnvs.add(new DataSourceEnv());
dataSourceEnvs.add(new DataSourceEnv());
Mockito.when(dataSourceEnvDao.listByTypeId(1l)).thenReturn(dataSourceEnvs);
- List<DataSourceEnv> actuallyDataSourceEnvs = dataSourceInfoService.listDataSourceEnvByType(1l);
- assertTrue(actuallyDataSourceEnvs.size()==2);
+ List<DataSourceEnv> actuallyDataSourceEnvs =
+ dataSourceInfoService.listDataSourceEnvByType(1l);
+ assertTrue(actuallyDataSourceEnvs.size() == 2);
}
+
@Test
- void testGetDataSourceEnv(){
+ void testGetDataSourceEnv() {
DataSourceEnv dataSourceEnv = new DataSourceEnv();
Mockito.when(dataSourceEnvDao.selectOneDetail(1l)).thenReturn(dataSourceEnv);
DataSourceEnv actuallyDataSourceEnv = dataSourceInfoService.getDataSourceEnv(1l);
@@ -240,27 +276,32 @@ public class DataSourceInfoServiceTest {
}
@Test
- void testRemoveDataSourceEnv(){
+ void testRemoveDataSourceEnv() {
DataSourceEnv dataSourceEnv = new DataSourceEnv();
dataSourceEnv.setId(1l);
dataSourceEnv.setDataSourceTypeId(1l);
Map<String, Object> connectParams = new HashMap<>();
- connectParams.put("key","value");
+ connectParams.put("key", "value");
dataSourceEnv.setConnectParams(connectParams);
List<DataSourceParamKeyDefinition> keyDefinitions = new ArrayList<>();
DataSourceParamKeyDefinition dsParamKeyDefinition = new DataSourceParamKeyDefinition();
keyDefinitions.add(dsParamKeyDefinition);
dsParamKeyDefinition.setKey("key");
dsParamKeyDefinition.setValueType(DataSourceParamKeyDefinition.ValueType.FILE);
- Mockito.when(dataSourceEnvDao.selectOneDetail(dataSourceEnv.getId())).thenReturn(dataSourceEnv);
+ Mockito.when(dataSourceEnvDao.selectOneDetail(dataSourceEnv.getId()))
+ .thenReturn(dataSourceEnv);
Mockito.when(dataSourceEnvDao.removeOne(dataSourceEnv.getId())).thenReturn(1);
- Mockito.when(dataSourceParamKeyDao.listByDataSourceTypeAndScope(dataSourceEnv.getDataSourceTypeId(),DataSourceParamKeyDefinition.Scope.ENV)).thenReturn(keyDefinitions);
+ Mockito.when(
+ dataSourceParamKeyDao.listByDataSourceTypeAndScope(
+ dataSourceEnv.getDataSourceTypeId(),
+ DataSourceParamKeyDefinition.Scope.ENV))
+ .thenReturn(keyDefinitions);
Long res = dataSourceInfoService.removeDataSourceEnv(dataSourceEnv.getId());
assertTrue(res == dataSourceEnv.getId());
}
@Test
- void testExpireDataSource(){
+ void testExpireDataSource() {
DataSource dataSource = buildDataSource();
Mockito.when(dataSourceDao.selectOne(dataSource.getId())).thenReturn(dataSource);
Mockito.when(dataSourceDao.expireOne(dataSource.getId())).thenReturn(1);
@@ -269,12 +310,12 @@ public class DataSourceInfoServiceTest {
}
@Test
- void testPublishByDataSourceId(){
+ void testPublishByDataSourceId() {
Mockito.when(dataSourceVersionDao.getLatestVersion(1l)).thenReturn(3l).thenReturn(1l);
- Mockito.when(dataSourceDao.setPublishedVersionId(1l,2l)).thenReturn(1);
- int res = dataSourceInfoService.publishByDataSourceId(1l,2l);
+ Mockito.when(dataSourceDao.setPublishedVersionId(1l, 2l)).thenReturn(1);
+ int res = dataSourceInfoService.publishByDataSourceId(1l, 2l);
assertTrue(res == 1);
- res = dataSourceInfoService.publishByDataSourceId(1l,2l);
+ res = dataSourceInfoService.publishByDataSourceId(1l, 2l);
assertTrue(res == 0);
}
@@ -288,7 +329,9 @@ public class DataSourceInfoServiceTest {
Long curVersion = 1l;
Long expectedVersion = curVersion + 1l;
Mockito.when(dataSourceVersionDao.getLatestVersion(1l)).thenReturn(curVersion);
- Long res = dataSourceInfoService.insertDataSourceParameter(keyDefinitionList, datasourceId, connectParams, username, comment);
+ Long res =
+ dataSourceInfoService.insertDataSourceParameter(
+ keyDefinitionList, datasourceId, connectParams, username, comment);
assertTrue(expectedVersion == res);
}
}
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/service/DataSourceRelateServiceTest.java b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/service/DataSourceRelateServiceTest.java
index fac46e5..184f40b 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/service/DataSourceRelateServiceTest.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/service/DataSourceRelateServiceTest.java
@@ -24,18 +24,14 @@ import static org.junit.jupiter.api.Assertions.*;
class DataSourceRelateServiceTest {
@Test
- void getKeyDefinitionsByType() {
- }
+ void getKeyDefinitionsByType() {}
@Test
- void testGetKeyDefinitionsByType() {
- }
+ void testGetKeyDefinitionsByType() {}
@Test
- void getAllDataSourceTypes() {
- }
+ void getAllDataSourceTypes() {}
@Test
- void getDataSourceType() {
- }
-}
\ No newline at end of file
+ void getDataSourceType() {}
+}
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/service/MetadataOperateServiceTest.java b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/service/MetadataOperateServiceTest.java
index 1731ad0..8e93e78 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/service/MetadataOperateServiceTest.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-datasource-manager/server/src/test/java/org/apache/linkis/datasourcemanager/core/service/MetadataOperateServiceTest.java
@@ -17,7 +17,6 @@
package org.apache.linkis.datasourcemanager.core.service;
-
import org.apache.linkis.common.exception.ErrorException;
import org.apache.linkis.common.exception.WarnException;
import org.apache.linkis.datasourcemanager.core.formdata.FormStreamContent;
@@ -26,6 +25,7 @@ import org.apache.linkis.metadatamanager.common.protocol.MetadataConnect;
import org.apache.linkis.metadatamanager.common.protocol.MetadataResponse;
import org.apache.linkis.rpc.BaseRPCSender;
import org.apache.linkis.rpc.Sender;
+
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
@@ -46,11 +46,9 @@ import static org.junit.jupiter.api.Assertions.*;
class MetadataOperateServiceTest {
private static final Logger logger = LoggerFactory.getLogger(MetadataOperateServiceTest.class);
- @InjectMocks
- MetadataOperateServiceImpl metadataOperateService;
+ @InjectMocks MetadataOperateServiceImpl metadataOperateService;
- @Mock
- BmlAppService bmlAppService;
+ @Mock BmlAppService bmlAppService;
@Test
void doRemoteConnect() throws ErrorException {
@@ -63,29 +61,30 @@ class MetadataOperateServiceTest {
InputStream inputStream = Mockito.mock(FileInputStream.class);
formStreamContent.setFileName(fileName);
formStreamContent.setStream(inputStream);
- connectParams.put("formStreamContent",formStreamContent);
- Mockito.when(bmlAppService.clientUploadResource(operator, fileName, inputStream)).thenReturn("10001");
+ connectParams.put("formStreamContent", formStreamContent);
+ Mockito.when(bmlAppService.clientUploadResource(operator, fileName, inputStream))
+ .thenReturn("10001");
Mockito.mockStatic(Sender.class);
BaseRPCSender baseRPCSender = Mockito.mock(BaseRPCSender.class);
Mockito.when(Sender.getSender("linkis-ps-metadata-manager")).thenReturn(baseRPCSender);
- MetadataConnect metadataConnect = new MetadataConnect(dataSourceType, operator, connectParams, "");
+ MetadataConnect metadataConnect =
+ new MetadataConnect(dataSourceType, operator, connectParams, "");
MetadataResponse ok = new MetadataResponse(true, "success");
MetadataResponse fail = new MetadataResponse(false, "fail");
- Mockito.when(baseRPCSender.ask(metadataConnect)).thenReturn(ok,fail);
- metadataOperateService.doRemoteConnect(mdRemoteServiceName,dataSourceType,operator,connectParams);
- Mockito.verify(baseRPCSender,Mockito.times(1)).ask(metadataConnect);
+ Mockito.when(baseRPCSender.ask(metadataConnect)).thenReturn(ok, fail);
+ metadataOperateService.doRemoteConnect(
+ mdRemoteServiceName, dataSourceType, operator, connectParams);
+ Mockito.verify(baseRPCSender, Mockito.times(1)).ask(metadataConnect);
- assertThrows(WarnException.class,()->metadataOperateService.doRemoteConnect(mdRemoteServiceName,dataSourceType,operator,connectParams));
- Mockito.verify(baseRPCSender,Mockito.times(2)).ask(metadataConnect);
+ assertThrows(
+ WarnException.class,
+ () ->
+ metadataOperateService.doRemoteConnect(
+ mdRemoteServiceName, dataSourceType, operator, connectParams));
+ Mockito.verify(baseRPCSender, Mockito.times(2)).ask(metadataConnect);
assertTrue(connectParams.get("formStreamContent").equals("10001"));
-
-
-
-
-
-
}
-}
\ No newline at end of file
+}
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-metadata-manager/server/src/test/java/org/apache/linkis/metadatamanager/server/WebApplicationServer.java b/linkis-public-enhancements/linkis-datasource/linkis-metadata-manager/server/src/test/java/org/apache/linkis/metadatamanager/server/WebApplicationServer.java
index f205677..83f2044 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-metadata-manager/server/src/test/java/org/apache/linkis/metadatamanager/server/WebApplicationServer.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-metadata-manager/server/src/test/java/org/apache/linkis/metadatamanager/server/WebApplicationServer.java
@@ -24,5 +24,4 @@ import org.springframework.context.annotation.ComponentScan;
@EnableAutoConfiguration
@ServletComponentScan
@ComponentScan
-public class WebApplicationServer {
-}
+public class WebApplicationServer {}
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-metadata-manager/server/src/test/java/org/apache/linkis/metadatamanager/server/restful/MetadataCoreRestfulTest.java b/linkis-public-enhancements/linkis-datasource/linkis-metadata-manager/server/src/test/java/org/apache/linkis/metadatamanager/server/restful/MetadataCoreRestfulTest.java
index 72df731..1b2c8cb 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-metadata-manager/server/src/test/java/org/apache/linkis/metadatamanager/server/restful/MetadataCoreRestfulTest.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-metadata-manager/server/src/test/java/org/apache/linkis/metadatamanager/server/restful/MetadataCoreRestfulTest.java
@@ -24,14 +24,7 @@ import org.apache.linkis.metadatamanager.server.service.MetadataAppService;
import org.apache.linkis.server.Message;
import org.apache.linkis.server.MessageStatus;
import org.apache.linkis.server.security.SecurityFilter;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.MockedStatic;
-import org.mockito.Mockito;
-import org.mockito.stubbing.OngoingStubbing;
+
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
@@ -41,81 +34,94 @@ import org.springframework.test.web.servlet.MockMvc;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
-import javax.servlet.http.HttpServletRequest;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
import java.util.ArrayList;
import java.util.HashMap;
-import static org.mockito.ArgumentMatchers.isA;
-
-
@ExtendWith({SpringExtension.class})
@AutoConfigureMockMvc
@SpringBootTest(classes = {WebApplicationServer.class})
class MetadataCoreRestfulTest {
- @Autowired
- protected MockMvc mockMvc;
+ @Autowired protected MockMvc mockMvc;
- @MockBean
- private MetadataAppService metadataAppService;
+ @MockBean private MetadataAppService metadataAppService;
private static MockedStatic<SecurityFilter> securityFilter;
@BeforeAll
- private static void init(){
+ private static void init() {
securityFilter = Mockito.mockStatic(SecurityFilter.class);
}
@AfterAll
- private static void close(){
+ private static void close() {
securityFilter.close();
}
-
@Test
void testGetDatabases() {
try {
String dataSourceId = "1l";
- String url = String.format("/metadatamanager/dbs/%s",dataSourceId);
- MultiValueMap<String,String> params = new LinkedMultiValueMap<>();
- params.add("system","");
+ String url = String.format("/metadatamanager/dbs/%s", dataSourceId);
+ MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
+ params.add("system", "");
MvcUtils mvcUtils = new MvcUtils(mockMvc);
- Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url,params));
- Assertions.assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("'system' is missing"));
- params.add("system","hive");
- Mockito.when(metadataAppService.getDatabasesByDsId(dataSourceId,",hive",null)).thenReturn(new ArrayList<>());
- res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url,params));
+ Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url, params));
+ Assertions.assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("'system' is missing"));
+ params.add("system", "hive");
+ Mockito.when(metadataAppService.getDatabasesByDsId(dataSourceId, ",hive", null))
+ .thenReturn(new ArrayList<>());
+ res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url, params));
Assertions.assertTrue(MessageStatus.SUCCESS() == res.getStatus());
- Mockito.doThrow(new ErrorException(1,"")).when(metadataAppService).getDatabasesByDsId(dataSourceId,",hive",null);
- res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url,params));
- Assertions.assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Fail to get database list"));
- }catch (Exception e){
- //ignore
+ Mockito.doThrow(new ErrorException(1, ""))
+ .when(metadataAppService)
+ .getDatabasesByDsId(dataSourceId, ",hive", null);
+ res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url, params));
+ Assertions.assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Fail to get database list"));
+ } catch (Exception e) {
+ // ignore
}
-
}
@Test
void testGetTables() throws Exception {
String dataSourceId = "1l";
String database = "hivedb";
- String url = String.format("/metadatamanager/tables/%s/db/%s",dataSourceId,database);
- MultiValueMap<String,String> params = new LinkedMultiValueMap<>();
- params.add("system","");
+ String url = String.format("/metadatamanager/tables/%s/db/%s", dataSourceId, database);
+ MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
+ params.add("system", "");
MvcUtils mvcUtils = new MvcUtils(mockMvc);
- Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url,params));
- Assertions.assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("'system' is missing"));
-
- params.add("system","hive");
- Mockito.when(metadataAppService.getTablesByDsId(dataSourceId,database,",hive",null)).thenReturn(new ArrayList<>());
- res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url,params));
+ Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url, params));
+ Assertions.assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("'system' is missing"));
+
+ params.add("system", "hive");
+ Mockito.when(metadataAppService.getTablesByDsId(dataSourceId, database, ",hive", null))
+ .thenReturn(new ArrayList<>());
+ res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url, params));
Assertions.assertTrue(MessageStatus.SUCCESS() == res.getStatus());
- Mockito.doThrow(new ErrorException(1,"")).when(metadataAppService).getTablesByDsId(dataSourceId,database,",hive",null);
- res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url,params));
- Assertions.assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Fail to get table list"));
+ Mockito.doThrow(new ErrorException(1, ""))
+ .when(metadataAppService)
+ .getTablesByDsId(dataSourceId, database, ",hive", null);
+ res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url, params));
+ Assertions.assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Fail to get table list"));
}
@Test
@@ -124,25 +130,36 @@ class MetadataCoreRestfulTest {
String dataSourceId = "1l";
String database = "hivedb";
String table = "testtab";
- String url = String.format("/metadatamanager/props/%s/db/%s/table/%s",dataSourceId,database,table);
- MultiValueMap<String,String> params = new LinkedMultiValueMap<>();
- params.add("system","");
+ String url =
+ String.format(
+ "/metadatamanager/props/%s/db/%s/table/%s",
+ dataSourceId, database, table);
+ MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
+ params.add("system", "");
MvcUtils mvcUtils = new MvcUtils(mockMvc);
- Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url,params));
- Assertions.assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("'system' is missing"));
-
- params.add("system","hive");
- Mockito.when(metadataAppService.getTablePropsByDsId(dataSourceId,database,table,",hive",null)).thenReturn(new HashMap<>());
- res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url,params));
+ Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url, params));
+ Assertions.assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("'system' is missing"));
+
+ params.add("system", "hive");
+ Mockito.when(
+ metadataAppService.getTablePropsByDsId(
+ dataSourceId, database, table, ",hive", null))
+ .thenReturn(new HashMap<>());
+ res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url, params));
Assertions.assertTrue(MessageStatus.SUCCESS() == res.getStatus());
- Mockito.doThrow(new ErrorException(1,"")).when(metadataAppService).getTablePropsByDsId(dataSourceId,database,table,",hive",null);
- res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url,params));
- Assertions.assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Fail to get table properties"));
- }catch (Exception e) {
- //ignore
+ Mockito.doThrow(new ErrorException(1, ""))
+ .when(metadataAppService)
+ .getTablePropsByDsId(dataSourceId, database, table, ",hive", null);
+ res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url, params));
+ Assertions.assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Fail to get table properties"));
+ } catch (Exception e) {
+ // ignore
}
-
}
@Test
@@ -151,25 +168,36 @@ class MetadataCoreRestfulTest {
String dataSourceId = "1l";
String database = "hivedb";
String table = "testtab";
- String url = String.format("/metadatamanager/partitions/%s/db/%s/table/%s",dataSourceId,database,table);
- MultiValueMap<String,String> params = new LinkedMultiValueMap<>();
- params.add("system","");
+ String url =
+ String.format(
+ "/metadatamanager/partitions/%s/db/%s/table/%s",
+ dataSourceId, database, table);
+ MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
+ params.add("system", "");
MvcUtils mvcUtils = new MvcUtils(mockMvc);
- Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url,params));
- Assertions.assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("'system' is missing"));
-
- params.add("system","hive");
- Mockito.when(metadataAppService.getPartitionsByDsId(dataSourceId,database,table,",hive",null)).thenReturn(new MetaPartitionInfo());
- res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url,params));
+ Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url, params));
+ Assertions.assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("'system' is missing"));
+
+ params.add("system", "hive");
+ Mockito.when(
+ metadataAppService.getPartitionsByDsId(
+ dataSourceId, database, table, ",hive", null))
+ .thenReturn(new MetaPartitionInfo());
+ res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url, params));
Assertions.assertTrue(MessageStatus.SUCCESS() == res.getStatus());
- Mockito.doThrow(new ErrorException(1,"")).when(metadataAppService).getPartitionsByDsId(dataSourceId,database,table,",hive",null);
- res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url,params));
- Assertions.assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Fail to get partitions"));
- }catch (Exception e){
- //ignore
+ Mockito.doThrow(new ErrorException(1, ""))
+ .when(metadataAppService)
+ .getPartitionsByDsId(dataSourceId, database, table, ",hive", null);
+ res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url, params));
+ Assertions.assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Fail to get partitions"));
+ } catch (Exception e) {
+ // ignore
}
-
}
@Test
@@ -178,24 +206,35 @@ class MetadataCoreRestfulTest {
String dataSourceId = "1l";
String database = "hivedb";
String table = "testtab";
- String url = String.format("/metadatamanager/columns/%s/db/%s/table/%s",dataSourceId,database,table);
- MultiValueMap<String,String> params = new LinkedMultiValueMap<>();
- params.add("system","");
+ String url =
+ String.format(
+ "/metadatamanager/columns/%s/db/%s/table/%s",
+ dataSourceId, database, table);
+ MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
+ params.add("system", "");
MvcUtils mvcUtils = new MvcUtils(mockMvc);
- Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url,params));
- Assertions.assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("'system' is missing"));
-
- params.add("system","hive");
- Mockito.when(metadataAppService.getColumns(dataSourceId,database,table,",hive",null)).thenReturn(new ArrayList<>());
- res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url,params));
+ Message res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url, params));
+ Assertions.assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("'system' is missing"));
+
+ params.add("system", "hive");
+ Mockito.when(
+ metadataAppService.getColumns(
+ dataSourceId, database, table, ",hive", null))
+ .thenReturn(new ArrayList<>());
+ res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url, params));
Assertions.assertTrue(MessageStatus.SUCCESS() == res.getStatus());
- Mockito.doThrow(new ErrorException(1,"")).when(metadataAppService).getColumns(dataSourceId,database,table,",hive",null);
- res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url,params));
- Assertions.assertTrue(MessageStatus.ERROR() == res.getStatus() && res.getMessage().contains("Fail to get column list"));
- }catch (Exception e){
- //ignore
+ Mockito.doThrow(new ErrorException(1, ""))
+ .when(metadataAppService)
+ .getColumns(dataSourceId, database, table, ",hive", null);
+ res = mvcUtils.getMessage(mvcUtils.buildMvcResultGet(url, params));
+ Assertions.assertTrue(
+ MessageStatus.ERROR() == res.getStatus()
+ && res.getMessage().contains("Fail to get column list"));
+ } catch (Exception e) {
+ // ignore
}
-
}
-}
\ No newline at end of file
+}
diff --git a/linkis-public-enhancements/linkis-datasource/linkis-metadata-manager/server/src/test/java/org/apache/linkis/metadatamanager/server/restful/MvcUtils.java b/linkis-public-enhancements/linkis-datasource/linkis-metadata-manager/server/src/test/java/org/apache/linkis/metadatamanager/server/restful/MvcUtils.java
index 2514d2a..e45a298 100644
--- a/linkis-public-enhancements/linkis-datasource/linkis-metadata-manager/server/src/test/java/org/apache/linkis/metadatamanager/server/restful/MvcUtils.java
+++ b/linkis-public-enhancements/linkis-datasource/linkis-metadata-manager/server/src/test/java/org/apache/linkis/metadatamanager/server/restful/MvcUtils.java
@@ -19,6 +19,7 @@ package org.apache.linkis.metadatamanager.server.restful;
import org.apache.linkis.common.utils.JsonUtils;
import org.apache.linkis.server.Message;
+
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
@@ -44,7 +45,8 @@ public class MvcUtils {
return mvcResult;
}
- public MvcResult buildMvcResultGet(String url, MultiValueMap<String,String> params) throws Exception {
+ public MvcResult buildMvcResultGet(String url, MultiValueMap<String, String> params)
+ throws Exception {
MvcResult mvcResult =
mockMvc.perform(get(url).params(params))
.andExpect(status().isOk())
@@ -53,7 +55,7 @@ public class MvcUtils {
return mvcResult;
}
- public MvcResult buildMvcResultPost(String url,String json) throws Exception {
+ public MvcResult buildMvcResultPost(String url, String json) throws Exception {
MvcResult mvcResult =
mockMvc.perform(post(url).contentType(MediaType.APPLICATION_JSON).content(json))
.andExpect(status().isOk())
@@ -61,6 +63,7 @@ public class MvcUtils {
.andReturn();
return mvcResult;
}
+
public MvcResult buildMvcResultPost(String url) throws Exception {
MvcResult mvcResult =
mockMvc.perform(post(url))
@@ -78,6 +81,7 @@ public class MvcUtils {
.andReturn();
return mvcResult;
}
+
public MvcResult buildMvcResultPut(String url) throws Exception {
MvcResult mvcResult =
mockMvc.perform(put(url))
@@ -102,5 +106,4 @@ public class MvcUtils {
.readValue(mvcResult.getResponse().getContentAsString(), Message.class);
return res;
}
-
}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@linkis.apache.org
For additional commands, e-mail: commits-help@linkis.apache.org