From ef782b3e04b0fe6df6c7070d2d9f056660e5777b Mon Sep 17 00:00:00 2001 From: laywin Date: Tue, 14 Nov 2023 16:23:42 +0800 Subject: [PATCH 01/12] undo_log table check optimize --- .../java/io/seata/core/constants/DBType.java | 17 +++++++++++ .../main/java/io/seata/rm/RMHandlerAT.java | 23 -------------- .../seata/rm/datasource/DataSourceProxy.java | 30 +++++++++++++++++++ .../java/io/seata/rm/RMHandlerATTest.java | 13 -------- 4 files changed, 47 insertions(+), 36 deletions(-) diff --git a/core/src/main/java/io/seata/core/constants/DBType.java b/core/src/main/java/io/seata/core/constants/DBType.java index 49063bb802e..f1dc3ea9e3e 100644 --- a/core/src/main/java/io/seata/core/constants/DBType.java +++ b/core/src/main/java/io/seata/core/constants/DBType.java @@ -17,6 +17,8 @@ import io.seata.common.util.StringUtils; +import java.util.Optional; + /** * database type * @@ -209,4 +211,19 @@ public static DBType valueof(String dbType) { throw new IllegalArgumentException("unknown dbtype:" + dbType); } + + /** + * optional of db type. + * + * @param dbType the db type + * @return optional of the db type + */ + public static Optional optionalof(String dbType) { + for (DBType dt : values()) { + if (StringUtils.equalsIgnoreCase(dt.name(), dbType)) { + return Optional.of(dt); + } + } + return Optional.empty(); + } } diff --git a/rm-datasource/src/main/java/io/seata/rm/RMHandlerAT.java b/rm-datasource/src/main/java/io/seata/rm/RMHandlerAT.java index 333a121a295..cc9d1971890 100644 --- a/rm-datasource/src/main/java/io/seata/rm/RMHandlerAT.java +++ b/rm-datasource/src/main/java/io/seata/rm/RMHandlerAT.java @@ -19,8 +19,6 @@ import java.sql.SQLException; import java.text.ParseException; import java.util.Date; -import java.util.Map; -import java.util.concurrent.ConcurrentHashMap; import io.seata.common.util.DateUtil; import io.seata.core.model.BranchType; @@ -44,8 +42,6 @@ public class RMHandlerAT extends AbstractRMHandler { private static final int LIMIT_ROWS = 3000; - private final Map undoLogTableExistRecord = new ConcurrentHashMap<>(); - @Override public void handle(UndoLogDeleteRequest request) { String resourceId = request.getResourceId(); @@ -56,12 +52,6 @@ public void handle(UndoLogDeleteRequest request) { return; } - boolean hasUndoLogTable = undoLogTableExistRecord.computeIfAbsent(resourceId, id -> checkUndoLogTableExist(dataSourceProxy)); - if (!hasUndoLogTable) { - LOGGER.debug("resource({}) has no undo_log table, UndoLogDeleteRequest will be ignored", resourceId); - return; - } - Date division = getLogCreated(request.getSaveDays()); UndoLogManager manager = getUndoLogManager(dataSourceProxy); @@ -80,19 +70,6 @@ public void handle(UndoLogDeleteRequest request) { } } - boolean checkUndoLogTableExist(DataSourceProxy dataSourceProxy) { - UndoLogManager manager = getUndoLogManager(dataSourceProxy); - try (Connection connection = getConnection(dataSourceProxy)) { - if (connection == null) { - return false; - } - return manager.hasUndoLogTable(connection); - } catch (Exception e) { - // should never happen, hasUndoLogTable method had catch all Exception - return false; - } - } - Connection getConnection(DataSourceProxy dataSourceProxy) { try { return dataSourceProxy.getPlainConnection(); diff --git a/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java b/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java index 48317a83516..1cf31acfe35 100644 --- a/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java +++ b/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java @@ -23,17 +23,24 @@ import javax.sql.DataSource; +import io.seata.common.ConfigurationKeys; import io.seata.common.Constants; +import io.seata.config.ConfigurationFactory; +import io.seata.core.constants.DBType; import io.seata.core.context.RootContext; import io.seata.core.model.BranchType; import io.seata.core.model.Resource; import io.seata.rm.DefaultResourceManager; import io.seata.rm.datasource.sql.struct.TableMetaCacheFactory; +import io.seata.rm.datasource.undo.UndoLogManager; +import io.seata.rm.datasource.undo.UndoLogManagerFactory; import io.seata.rm.datasource.util.JdbcUtils; import io.seata.sqlparser.util.JdbcConstants; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import static io.seata.common.DefaultValues.DEFAULT_TRANSACTION_UNDO_LOG_TABLE; + /** * The type Data source proxy. * @@ -92,6 +99,9 @@ private void init(DataSource dataSource, String resourceGroupId) { getMySQLAdaptiveType(connection); } version = selectDbVersion(connection); + + checkUndoLogTableExist(connection); + } catch (SQLException e) { throw new IllegalStateException("can not init dataSource", e); } @@ -120,6 +130,26 @@ private void getMySQLAdaptiveType(Connection connection) { } } + /** + * check existence of undolog table + * + * if the table not exist fast fail, or else keep silence + * + * @param conn db connection + */ + private void checkUndoLogTableExist(Connection conn) { + if (DBType.optionalof(dbType).isPresent()) { + UndoLogManager undoLogManager = UndoLogManagerFactory.getUndoLogManager(dbType); + boolean undoLogTableExist = undoLogManager.hasUndoLogTable(conn); + if (!undoLogTableExist) { + String undoLogTableName = ConfigurationFactory.getInstance() + .getConfig(ConfigurationKeys.TRANSACTION_UNDO_LOG_TABLE, DEFAULT_TRANSACTION_UNDO_LOG_TABLE); + String errMsg = String.format("in AT mode, %s table not exist", undoLogTableName); + throw new IllegalStateException(errMsg); + } + } + } + /** * publish tableMeta refresh event */ diff --git a/rm-datasource/src/test/java/io/seata/rm/RMHandlerATTest.java b/rm-datasource/src/test/java/io/seata/rm/RMHandlerATTest.java index 3ae96f51d0d..f5a80f2dfea 100644 --- a/rm-datasource/src/test/java/io/seata/rm/RMHandlerATTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/RMHandlerATTest.java @@ -48,22 +48,9 @@ void hasUndoLogTableTest() { for (int i = 0; i < testTimes; i++) { handler.handle(request); } - verify(handler, times(1)).checkUndoLogTableExist(any()); verify(handler, times(testTimes)).deleteUndoLog(any(), any(), any()); } - @Test - void noUndoLogTableTest() { - RMHandlerAT handler = buildHandler(false); - UndoLogDeleteRequest request = buildRequest(); - int testTimes = 5; - for (int i = 0; i < testTimes; i++) { - handler.handle(request); - } - verify(handler, times(1)).checkUndoLogTableExist(any()); - verify(handler, never()).deleteUndoLog(any(), any(), any()); - } - private RMHandlerAT buildHandler(boolean hasUndoLogTable) { RMHandlerAT handler = spy(new RMHandlerAT()); DataSourceManager dataSourceManager = mock(DataSourceManager.class); From 1df81ebcc07992965c9a8f196b2e25c47c6a4afd Mon Sep 17 00:00:00 2001 From: laywin Date: Tue, 14 Nov 2023 21:37:57 +0800 Subject: [PATCH 02/12] optimize & add modify record --- changes/en-us/2.0.0.md | 1 + changes/zh-cn/2.0.0.md | 1 + .../java/io/seata/rm/datasource/DataSourceProxy.java | 9 ++++++++- 3 files changed, 10 insertions(+), 1 deletion(-) diff --git a/changes/en-us/2.0.0.md b/changes/en-us/2.0.0.md index 49ee6f02f5d..f8a1df9967c 100644 --- a/changes/en-us/2.0.0.md +++ b/changes/en-us/2.0.0.md @@ -151,6 +151,7 @@ The version is updated as follows: - [[#5951](https://github.com/seata/seata/pull/5951)] remove un support config in jdk17 - [[#5959](https://github.com/seata/seata/pull/5959)] modify code style and remove unused import - [[#6002](https://github.com/seata/seata/pull/6002)] remove fst serialization +- [[#6031](https://github.com/seata/seata/pull/6031)] add a check for the existence of the undolog table ### security: diff --git a/changes/zh-cn/2.0.0.md b/changes/zh-cn/2.0.0.md index 73012f63a0d..830830509de 100644 --- a/changes/zh-cn/2.0.0.md +++ b/changes/zh-cn/2.0.0.md @@ -152,6 +152,7 @@ Seata 是一款开源的分布式事务解决方案，提供高性能和简单 - [[#5951](https://github.com/seata/seata/pull/5951)] 删除在 jdk17 中不支持的配置项 - [[#5959](https://github.com/seata/seata/pull/5959)] 修正代码风格问题及去除无用的类引用 - [[#6002](https://github.com/seata/seata/pull/6002)] 移除fst序列化模块 +- [[#6031](https://github.com/seata/seata/pull/6031)] 添加undo_log表的存在性校验 ### security: diff --git a/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java b/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java index 1cf31acfe35..89c0705e052 100644 --- a/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java +++ b/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java @@ -25,6 +25,7 @@ import io.seata.common.ConfigurationKeys; import io.seata.common.Constants; +import io.seata.common.loader.EnhancedServiceNotFoundException; import io.seata.config.ConfigurationFactory; import io.seata.core.constants.DBType; import io.seata.core.context.RootContext; @@ -139,7 +140,13 @@ private void getMySQLAdaptiveType(Connection connection) { */ private void checkUndoLogTableExist(Connection conn) { if (DBType.optionalof(dbType).isPresent()) { - UndoLogManager undoLogManager = UndoLogManagerFactory.getUndoLogManager(dbType); + UndoLogManager undoLogManager; + try { + undoLogManager = UndoLogManagerFactory.getUndoLogManager(dbType); + } catch (EnhancedServiceNotFoundException e) { + LOGGER.error("can't find undoLogManager service provider for dbtype: {}", dbType); + return; + } boolean undoLogTableExist = undoLogManager.hasUndoLogTable(conn); if (!undoLogTableExist) { String undoLogTableName = ConfigurationFactory.getInstance() From 8e9232559a02d0986e05603a4de16f4e7858c366 Mon Sep 17 00:00:00 2001 From: laywin Date: Tue, 14 Nov 2023 22:08:36 +0800 Subject: [PATCH 03/12] adjust indentation --- .../src/main/java/io/seata/rm/datasource/DataSourceProxy.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java b/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java index 89c0705e052..790868439ed 100644 --- a/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java +++ b/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java @@ -142,7 +142,7 @@ private void checkUndoLogTableExist(Connection conn) { if (DBType.optionalof(dbType).isPresent()) { UndoLogManager undoLogManager; try { - undoLogManager = UndoLogManagerFactory.getUndoLogManager(dbType); + undoLogManager = UndoLogManagerFactory.getUndoLogManager(dbType); } catch (EnhancedServiceNotFoundException e) { LOGGER.error("can't find undoLogManager service provider for dbtype: {}", dbType); return; From 7482281728f0a51fad0448ec095f17a5dc27018b Mon Sep 17 00:00:00 2001 From: laywin Date: Tue, 14 Nov 2023 16:23:42 +0800 Subject: [PATCH 04/12] undo_log table check optimize --- .../java/io/seata/core/constants/DBType.java | 17 +++++++++++ .../main/java/io/seata/rm/RMHandlerAT.java | 23 --------------- .../seata/rm/datasource/DataSourceProxy.java | 29 +++++++++++++++++++ .../java/io/seata/rm/RMHandlerATTest.java | 13 --------- 4 files changed, 46 insertions(+), 36 deletions(-) diff --git a/core/src/main/java/io/seata/core/constants/DBType.java b/core/src/main/java/io/seata/core/constants/DBType.java index 49063bb802e..f1dc3ea9e3e 100644 --- a/core/src/main/java/io/seata/core/constants/DBType.java +++ b/core/src/main/java/io/seata/core/constants/DBType.java @@ -17,6 +17,8 @@ import io.seata.common.util.StringUtils; +import java.util.Optional; + /** * database type * @@ -209,4 +211,19 @@ public static DBType valueof(String dbType) { throw new IllegalArgumentException("unknown dbtype:" + dbType); } + + /** + * optional of db type. + * + * @param dbType the db type + * @return optional of the db type + */ + public static Optional optionalof(String dbType) { + for (DBType dt : values()) { + if (StringUtils.equalsIgnoreCase(dt.name(), dbType)) { + return Optional.of(dt); + } + } + return Optional.empty(); + } } diff --git a/rm-datasource/src/main/java/io/seata/rm/RMHandlerAT.java b/rm-datasource/src/main/java/io/seata/rm/RMHandlerAT.java index 333a121a295..cc9d1971890 100644 --- a/rm-datasource/src/main/java/io/seata/rm/RMHandlerAT.java +++ b/rm-datasource/src/main/java/io/seata/rm/RMHandlerAT.java @@ -19,8 +19,6 @@ import java.sql.SQLException; import java.text.ParseException; import java.util.Date; -import java.util.Map; -import java.util.concurrent.ConcurrentHashMap; import io.seata.common.util.DateUtil; import io.seata.core.model.BranchType; @@ -44,8 +42,6 @@ public class RMHandlerAT extends AbstractRMHandler { private static final int LIMIT_ROWS = 3000; - private final Map undoLogTableExistRecord = new ConcurrentHashMap<>(); - @Override public void handle(UndoLogDeleteRequest request) { String resourceId = request.getResourceId(); @@ -56,12 +52,6 @@ public void handle(UndoLogDeleteRequest request) { return; } - boolean hasUndoLogTable = undoLogTableExistRecord.computeIfAbsent(resourceId, id -> checkUndoLogTableExist(dataSourceProxy)); - if (!hasUndoLogTable) { - LOGGER.debug("resource({}) has no undo_log table, UndoLogDeleteRequest will be ignored", resourceId); - return; - } - Date division = getLogCreated(request.getSaveDays()); UndoLogManager manager = getUndoLogManager(dataSourceProxy); @@ -80,19 +70,6 @@ public void handle(UndoLogDeleteRequest request) { } } - boolean checkUndoLogTableExist(DataSourceProxy dataSourceProxy) { - UndoLogManager manager = getUndoLogManager(dataSourceProxy); - try (Connection connection = getConnection(dataSourceProxy)) { - if (connection == null) { - return false; - } - return manager.hasUndoLogTable(connection); - } catch (Exception e) { - // should never happen, hasUndoLogTable method had catch all Exception - return false; - } - } - Connection getConnection(DataSourceProxy dataSourceProxy) { try { return dataSourceProxy.getPlainConnection(); diff --git a/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java b/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java index 6d930ea4009..d2971371f96 100644 --- a/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java +++ b/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java @@ -22,18 +22,25 @@ import javax.sql.DataSource; +import io.seata.common.ConfigurationKeys; import io.seata.common.Constants; +import io.seata.config.ConfigurationFactory; +import io.seata.core.constants.DBType; import io.seata.core.context.RootContext; import io.seata.core.model.BranchType; import io.seata.core.model.Resource; import io.seata.rm.DefaultResourceManager; import io.seata.rm.datasource.sql.struct.TableMetaCacheFactory; +import io.seata.rm.datasource.undo.UndoLogManager; +import io.seata.rm.datasource.undo.UndoLogManagerFactory; import io.seata.rm.datasource.util.JdbcUtils; import io.seata.sqlparser.util.JdbcConstants; import org.apache.commons.lang.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import static io.seata.common.DefaultValues.DEFAULT_TRANSACTION_UNDO_LOG_TABLE; + /** * The type Data source proxy. * @@ -101,6 +108,8 @@ private void init(DataSource dataSource, String resourceGroupId) { validMySQLVersion(connection); checkDerivativeProduct(); } + checkUndoLogTableExist(connection); + } catch (SQLException e) { throw new IllegalStateException("can not init dataSource", e); } @@ -143,6 +152,26 @@ private boolean isPolardbXProduct() { return false; } + /** + * check existence of undolog table + * + * if the table not exist fast fail, or else keep silence + * + * @param conn db connection + */ + private void checkUndoLogTableExist(Connection conn) { + if (DBType.optionalof(dbType).isPresent()) { + UndoLogManager undoLogManager = UndoLogManagerFactory.getUndoLogManager(dbType); + boolean undoLogTableExist = undoLogManager.hasUndoLogTable(conn); + if (!undoLogTableExist) { + String undoLogTableName = ConfigurationFactory.getInstance() + .getConfig(ConfigurationKeys.TRANSACTION_UNDO_LOG_TABLE, DEFAULT_TRANSACTION_UNDO_LOG_TABLE); + String errMsg = String.format("in AT mode, %s table not exist", undoLogTableName); + throw new IllegalStateException(errMsg); + } + } + } + /** * publish tableMeta refresh event */ diff --git a/rm-datasource/src/test/java/io/seata/rm/RMHandlerATTest.java b/rm-datasource/src/test/java/io/seata/rm/RMHandlerATTest.java index 3ae96f51d0d..f5a80f2dfea 100644 --- a/rm-datasource/src/test/java/io/seata/rm/RMHandlerATTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/RMHandlerATTest.java @@ -48,22 +48,9 @@ void hasUndoLogTableTest() { for (int i = 0; i < testTimes; i++) { handler.handle(request); } - verify(handler, times(1)).checkUndoLogTableExist(any()); verify(handler, times(testTimes)).deleteUndoLog(any(), any(), any()); } - @Test - void noUndoLogTableTest() { - RMHandlerAT handler = buildHandler(false); - UndoLogDeleteRequest request = buildRequest(); - int testTimes = 5; - for (int i = 0; i < testTimes; i++) { - handler.handle(request); - } - verify(handler, times(1)).checkUndoLogTableExist(any()); - verify(handler, never()).deleteUndoLog(any(), any(), any()); - } - private RMHandlerAT buildHandler(boolean hasUndoLogTable) { RMHandlerAT handler = spy(new RMHandlerAT()); DataSourceManager dataSourceManager = mock(DataSourceManager.class); From 522c386c9f3766ce1e6ee8adef95a159602840ca Mon Sep 17 00:00:00 2001 From: laywin Date: Tue, 14 Nov 2023 21:37:57 +0800 Subject: [PATCH 05/12] optimize & add modify record --- .../java/io/seata/rm/datasource/DataSourceProxy.java | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java b/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java index d2971371f96..32320649793 100644 --- a/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java +++ b/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java @@ -24,6 +24,7 @@ import io.seata.common.ConfigurationKeys; import io.seata.common.Constants; +import io.seata.common.loader.EnhancedServiceNotFoundException; import io.seata.config.ConfigurationFactory; import io.seata.core.constants.DBType; import io.seata.core.context.RootContext; @@ -161,7 +162,13 @@ private boolean isPolardbXProduct() { */ private void checkUndoLogTableExist(Connection conn) { if (DBType.optionalof(dbType).isPresent()) { - UndoLogManager undoLogManager = UndoLogManagerFactory.getUndoLogManager(dbType); + UndoLogManager undoLogManager; + try { + undoLogManager = UndoLogManagerFactory.getUndoLogManager(dbType); + } catch (EnhancedServiceNotFoundException e) { + LOGGER.error("can't find undoLogManager service provider for dbtype: {}", dbType); + return; + } boolean undoLogTableExist = undoLogManager.hasUndoLogTable(conn); if (!undoLogTableExist) { String undoLogTableName = ConfigurationFactory.getInstance() From 0444780976d9c1efe000cfde49b341a1a9db6da1 Mon Sep 17 00:00:00 2001 From: laywin Date: Tue, 14 Nov 2023 22:08:36 +0800 Subject: [PATCH 06/12] adjust indentation --- .../src/main/java/io/seata/rm/datasource/DataSourceProxy.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java b/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java index 32320649793..b09bc80ed78 100644 --- a/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java +++ b/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java @@ -164,7 +164,7 @@ private void checkUndoLogTableExist(Connection conn) { if (DBType.optionalof(dbType).isPresent()) { UndoLogManager undoLogManager; try { - undoLogManager = UndoLogManagerFactory.getUndoLogManager(dbType); + undoLogManager = UndoLogManagerFactory.getUndoLogManager(dbType); } catch (EnhancedServiceNotFoundException e) { LOGGER.error("can't find undoLogManager service provider for dbtype: {}", dbType); return; From 881aaf42e3e1c11827fbc513cc7738d43da62116 Mon Sep 17 00:00:00 2001 From: laywin Date: Tue, 21 Nov 2023 16:22:57 +0800 Subject: [PATCH 07/12] add unit test --- .../test/java/io/seata/rm/RMHandlerATTest.java | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/rm-datasource/src/test/java/io/seata/rm/RMHandlerATTest.java b/rm-datasource/src/test/java/io/seata/rm/RMHandlerATTest.java index f5a80f2dfea..35670e78f11 100644 --- a/rm-datasource/src/test/java/io/seata/rm/RMHandlerATTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/RMHandlerATTest.java @@ -22,6 +22,7 @@ import org.junit.jupiter.api.Test; import java.sql.Connection; +import java.sql.SQLException; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -41,8 +42,8 @@ class RMHandlerATTest { @Test - void hasUndoLogTableTest() { - RMHandlerAT handler = buildHandler(true); + void hasNormalUndoLogTableTest() { + RMHandlerAT handler = buildHandler(false); UndoLogDeleteRequest request = buildRequest(); int testTimes = 5; for (int i = 0; i < testTimes; i++) { @@ -51,6 +52,16 @@ void hasUndoLogTableTest() { verify(handler, times(testTimes)).deleteUndoLog(any(), any(), any()); } + @Test + void hasErrorUndoLogTableTest() { + RMHandlerAT handler = buildHandler(true); + UndoLogDeleteRequest request = buildRequest(); + request.setSaveDays((short) -1); + int testTimes = 1; + handler.handle(request); + verify(handler, times(testTimes)).deleteUndoLog(any(), any(), any()); + } + private RMHandlerAT buildHandler(boolean hasUndoLogTable) { RMHandlerAT handler = spy(new RMHandlerAT()); DataSourceManager dataSourceManager = mock(DataSourceManager.class); From b8f822c14bb9b12f47d4b6f116f4073792262d3c Mon Sep 17 00:00:00 2001 From: laywin Date: Tue, 21 Nov 2023 16:29:36 +0800 Subject: [PATCH 08/12] move pr record --- changes/en-us/2.x.md | 2 +- changes/zh-cn/2.x.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/changes/en-us/2.x.md b/changes/en-us/2.x.md index af9ed444f59..09ece65e7c9 100644 --- a/changes/en-us/2.x.md +++ b/changes/en-us/2.x.md @@ -9,7 +9,7 @@ Add changes here for all PR submitted to the 2.x branch. - [[#PR_NO](https://github.com/seata/seata/pull/PR_NO)] A brief and accurate description of PR ### optimize: -- [[#PR_NO](https://github.com/seata/seata/pull/PR_NO)] A brief and accurate description of PR +- [[#6031](https://github.com/seata/seata/pull/6031)] add a check for the existence of the undolog table ### security: - [[#PR_NO](https://github.com/seata/seata/pull/PR_NO)] A brief and accurate description of PR diff --git a/changes/zh-cn/2.x.md b/changes/zh-cn/2.x.md index dba99a3d98e..90270ad5e10 100644 --- a/changes/zh-cn/2.x.md +++ b/changes/zh-cn/2.x.md @@ -9,7 +9,7 @@ - [[#PR_NO](https://github.com/seata/seata/pull/PR_NO)] 准确简要的PR描述 ### optimize: -- [[#PR_NO](https://github.com/seata/seata/pull/PR_NO)] 准确简要的PR描述 +- [[#6031](https://github.com/seata/seata/pull/6031)] 添加undo_log表的存在性校验 ### security: - [[#PR_NO](https://github.com/seata/seata/pull/PR_NO)] 准确简要的PR描述 From e36326e2889ce8a671d37695bc61112249a90d72 Mon Sep 17 00:00:00 2001 From: laywin Date: Tue, 21 Nov 2023 17:17:19 +0800 Subject: [PATCH 09/12] modify unit test --- .../test/java/io/seata/rm/RMHandlerATTest.java | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/rm-datasource/src/test/java/io/seata/rm/RMHandlerATTest.java b/rm-datasource/src/test/java/io/seata/rm/RMHandlerATTest.java index 35670e78f11..f3d34f25c22 100644 --- a/rm-datasource/src/test/java/io/seata/rm/RMHandlerATTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/RMHandlerATTest.java @@ -23,7 +23,9 @@ import java.sql.Connection; import java.sql.SQLException; +import java.util.Date; +import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.times; @@ -42,7 +44,7 @@ class RMHandlerATTest { @Test - void hasNormalUndoLogTableTest() { + void testNormalDeleteUndoLogTable() throws SQLException { RMHandlerAT handler = buildHandler(false); UndoLogDeleteRequest request = buildRequest(); int testTimes = 5; @@ -53,16 +55,15 @@ void hasNormalUndoLogTableTest() { } @Test - void hasErrorUndoLogTableTest() { + void testErrorDeleteUndoLogTable() throws SQLException { RMHandlerAT handler = buildHandler(true); UndoLogDeleteRequest request = buildRequest(); request.setSaveDays((short) -1); - int testTimes = 1; handler.handle(request); - verify(handler, times(testTimes)).deleteUndoLog(any(), any(), any()); + verify(handler, times(1)).deleteUndoLog(any(), any(), any()); } - private RMHandlerAT buildHandler(boolean hasUndoLogTable) { + private RMHandlerAT buildHandler(boolean errorDeleteUndologTable) throws SQLException { RMHandlerAT handler = spy(new RMHandlerAT()); DataSourceManager dataSourceManager = mock(DataSourceManager.class); doReturn(dataSourceManager).when(handler).getResourceManager(); @@ -76,9 +77,14 @@ private RMHandlerAT buildHandler(boolean hasUndoLogTable) { }); UndoLogManager manager = mock(UndoLogManager.class); - when(manager.hasUndoLogTable(any())).thenReturn(hasUndoLogTable); + when(manager.hasUndoLogTable(any())).thenReturn(true); doReturn(manager).when(handler).getUndoLogManager(any()); + if (errorDeleteUndologTable) { + when(manager.deleteUndoLogByLogCreated(any(Date.class), anyInt(), any(Connection.class))) + .thenThrow(new SQLException()); + } + return handler; } From 0bf3847ad48ff9032fd1171136d52d3dc24e3759 Mon Sep 17 00:00:00 2001 From: laywin Date: Thu, 23 Nov 2023 20:13:05 +0800 Subject: [PATCH 10/12] add Github ID --- changes/en-us/2.x.md | 1 + 1 file changed, 1 insertion(+) diff --git a/changes/en-us/2.x.md b/changes/en-us/2.x.md index 09ece65e7c9..1d540384c27 100644 --- a/changes/en-us/2.x.md +++ b/changes/en-us/2.x.md @@ -21,6 +21,7 @@ Thanks to these contributors for their code commits. Please report an unintended - [slievrly](https://github.com/slievrly) +- [laywin](https://github.com/laywin) Also, we receive many valuable issues, questions and advices from our community. Thanks for you all. From 12f81099cd5237e345062a2916f47584a7dafd63 Mon Sep 17 00:00:00 2001 From: laywin Date: Sun, 26 Nov 2023 13:01:17 +0800 Subject: [PATCH 11/12] 1. update mockito version to 4.5.1 same as seata server to support static mock 2. throw exception when the db type not support in AT mode 3. add author register info --- changes/zh-cn/2.x.md | 1 + .../io/seata/config/ConfigFutureTest.java | 4 +- .../java/io/seata/core/constants/DBType.java | 16 ----- dependencies/pom.xml | 7 ++- pom.xml | 5 ++ .../seata/rm/datasource/DataSourceProxy.java | 29 +++++---- .../rm/datasource/DataSourceProxyTest.java | 62 ++++++++++++++++++- .../PreparedStatementProxyTest.java | 11 +++- .../rm/datasource/StatementProxyTest.java | 8 ++- .../datasource/exec/DeleteExecutorTest.java | 13 +++- .../rm/datasource/exec/MultiExecutorTest.java | 14 ++++- .../rm/datasource/exec/PlainExecutorTest.java | 4 +- .../exec/SelectForUpdateExecutorTest.java | 10 ++- .../datasource/exec/UpdateExecutorTest.java | 12 +++- .../exec/UpdateJoinExecutorTest.java | 9 ++- .../sql/struct/TableRecordsTest.java | 30 ++++----- .../struct/cache/DmTableMetaCacheTest.java | 3 +- .../cache/MariadbTableMetaCacheTest.java | 11 +++- .../struct/cache/MysqlTableMetaCacheTest.java | 14 ++++- .../cache/OracleTableMetaCacheTest.java | 9 ++- .../cache/PostgresqlTableMetaCacheTest.java | 11 +++- .../cache/SqlServerTableMetaCacheTest.java | 12 +++- .../seata/rm/datasource/undo/BaseH2Test.java | 8 ++- .../mariadb/MariadbUndoLogManagerTest.java | 17 +++-- .../undo/mysql/MySQLUndoLogManagerTest.java | 16 +++-- .../polardbx/PolarDBXUndoLogManagerTest.java | 16 +++-- 26 files changed, 265 insertions(+), 87 deletions(-) diff --git a/changes/zh-cn/2.x.md b/changes/zh-cn/2.x.md index 90270ad5e10..f5424b2a1f5 100644 --- a/changes/zh-cn/2.x.md +++ b/changes/zh-cn/2.x.md @@ -21,5 +21,6 @@ - [slievrly](https://github.com/slievrly) +- [laywin](https://github.com/laywin) 同时，我们收到了社区反馈的很多有价值的issue和建议，非常感谢大家。 diff --git a/config/seata-config-core/src/test/java/io/seata/config/ConfigFutureTest.java b/config/seata-config-core/src/test/java/io/seata/config/ConfigFutureTest.java index 60ffb299527..57daca70fb5 100644 --- a/config/seata-config-core/src/test/java/io/seata/config/ConfigFutureTest.java +++ b/config/seata-config-core/src/test/java/io/seata/config/ConfigFutureTest.java @@ -21,7 +21,6 @@ import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; -import org.mockito.internal.util.reflection.FieldSetter; import java.lang.reflect.Field; import java.util.concurrent.CompletableFuture; @@ -44,7 +43,8 @@ void testGet() throws NoSuchFieldException, IllegalAccessException, ExecutionExc // mock field origin = Mockito.spy(origin); // set mocked field to object - FieldSetter.setField(configFuture, originField, origin); + originField.setAccessible(true); + originField.set(configFuture, origin); Mockito.doThrow(ExecutionException.class).when(origin).get(Mockito.anyLong(), Mockito.any()); Assertions.assertThrows(ShouldNeverHappenException.class, configFuture::get); diff --git a/core/src/main/java/io/seata/core/constants/DBType.java b/core/src/main/java/io/seata/core/constants/DBType.java index f1dc3ea9e3e..2a3093e4c63 100644 --- a/core/src/main/java/io/seata/core/constants/DBType.java +++ b/core/src/main/java/io/seata/core/constants/DBType.java @@ -210,20 +210,4 @@ public static DBType valueof(String dbType) { } throw new IllegalArgumentException("unknown dbtype:" + dbType); } - - - /** - * optional of db type. - * - * @param dbType the db type - * @return optional of the db type - */ - public static Optional optionalof(String dbType) { - for (DBType dt : values()) { - if (StringUtils.equalsIgnoreCase(dt.name(), dbType)) { - return Optional.of(dt); - } - } - return Optional.empty(); - } } diff --git a/dependencies/pom.xml b/dependencies/pom.xml index 8c557cc288d..477094f7e8f 100644 --- a/dependencies/pom.xml +++ b/dependencies/pom.xml @@ -118,7 +118,7 @@ 1.4.3 - 2.23.4 + 4.5.1 3.12.2 9.4.38.v20210224 3.1.7 @@ -701,6 +701,11 @@ mockito-junit-jupiter ${mockito.version} + + org.mockito + mockito-inline + ${mockito.version} + org.assertj assertj-core diff --git a/pom.xml b/pom.xml index f2371a43ce7..4d7b21b35e8 100644 --- a/pom.xml +++ b/pom.xml @@ -92,6 +92,11 @@ mockito-junit-jupiter test + + org.mockito + mockito-inline + test + org.assertj assertj-core diff --git a/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java b/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java index b09bc80ed78..aa186b3d818 100644 --- a/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java +++ b/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java @@ -161,21 +161,20 @@ private boolean isPolardbXProduct() { * @param conn db connection */ private void checkUndoLogTableExist(Connection conn) { - if (DBType.optionalof(dbType).isPresent()) { - UndoLogManager undoLogManager; - try { - undoLogManager = UndoLogManagerFactory.getUndoLogManager(dbType); - } catch (EnhancedServiceNotFoundException e) { - LOGGER.error("can't find undoLogManager service provider for dbtype: {}", dbType); - return; - } - boolean undoLogTableExist = undoLogManager.hasUndoLogTable(conn); - if (!undoLogTableExist) { - String undoLogTableName = ConfigurationFactory.getInstance() - .getConfig(ConfigurationKeys.TRANSACTION_UNDO_LOG_TABLE, DEFAULT_TRANSACTION_UNDO_LOG_TABLE); - String errMsg = String.format("in AT mode, %s table not exist", undoLogTableName); - throw new IllegalStateException(errMsg); - } + UndoLogManager undoLogManager; + try { + undoLogManager = UndoLogManagerFactory.getUndoLogManager(dbType); + } catch (EnhancedServiceNotFoundException e) { + String errMsg = String.format("AT mode don't support the the dbtype: %s", dbType); + throw new IllegalStateException(errMsg, e); + } + + boolean undoLogTableExist = undoLogManager.hasUndoLogTable(conn); + if (!undoLogTableExist) { + String undoLogTableName = ConfigurationFactory.getInstance() + .getConfig(ConfigurationKeys.TRANSACTION_UNDO_LOG_TABLE, DEFAULT_TRANSACTION_UNDO_LOG_TABLE); + String errMsg = String.format("in AT mode, %s table not exist", undoLogTableName); + throw new IllegalStateException(errMsg); } } diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/DataSourceProxyTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/DataSourceProxyTest.java index d8da5d26acf..e351f674bee 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/DataSourceProxyTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/DataSourceProxyTest.java @@ -16,6 +16,7 @@ package io.seata.rm.datasource; import java.lang.reflect.Field; +import java.sql.Connection; import java.sql.SQLException; import javax.sql.DataSource; @@ -23,8 +24,17 @@ import io.seata.rm.datasource.mock.MockDataSource; import io.seata.rm.datasource.mock.MockDriver; import io.seata.rm.datasource.sql.struct.TableMetaCacheFactory; +import io.seata.rm.datasource.undo.UndoLogManagerFactory; +import io.seata.rm.datasource.undo.mysql.MySQLUndoLogManager; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; +import org.mockito.MockedStatic; +import org.mockito.Mockito; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.*; /** * @author ph3636 @@ -34,7 +44,6 @@ public class DataSourceProxyTest { @Test public void test_constructor() { DataSource dataSource = new MockDataSource(); - DataSourceProxy dataSourceProxy = new DataSourceProxy(dataSource); Assertions.assertEquals(dataSourceProxy.getTargetDataSource(), dataSource); @@ -42,6 +51,42 @@ public void test_constructor() { Assertions.assertEquals(dataSourceProxy2.getTargetDataSource(), dataSource); } + @Test + public void testNotSupportDb() { + final MockDriver mockDriver = new MockDriver(); + final String username = "username"; + final String jdbcUrl = "jdbc:mock:xxx"; + + // create data source + final DruidDataSource dataSource = new DruidDataSource(); + dataSource.setUrl(jdbcUrl); + dataSource.setDriver(mockDriver); + dataSource.setUsername(username); + dataSource.setPassword("password"); + + Throwable throwable = Assertions.assertThrows(IllegalStateException.class, () -> new DataSourceProxy(dataSource)); + assertThat(throwable).hasMessageContaining("AT mode don't support the the dbtype"); + } + + + @Test + public void testUndologTableNotExist() { + DataSource dataSource = new MockDataSource(); + + MockedStatic undoLogManagerFactoryMockedStatic = Mockito.mockStatic(UndoLogManagerFactory.class); + + MySQLUndoLogManager mysqlUndoLogManager = mock(MySQLUndoLogManager.class); + undoLogManagerFactoryMockedStatic.when(()->UndoLogManagerFactory.getUndoLogManager(anyString())) + .thenReturn(mysqlUndoLogManager); + + doReturn(false).when(mysqlUndoLogManager).hasUndoLogTable(any(Connection.class)); + + Throwable throwable = Assertions.assertThrows(IllegalStateException.class, () -> new DataSourceProxy(dataSource)); + undoLogManagerFactoryMockedStatic.close(); + + assertThat(throwable).hasMessageContaining("table not exist"); + } + @Test public void getResourceIdTest() throws SQLException, NoSuchFieldException, IllegalAccessException { // Disable 'DataSourceProxy.tableMetaExecutor' to prevent unit tests from being affected @@ -62,7 +107,7 @@ public void getResourceIdTest() throws SQLException, NoSuchFieldException, Illeg dataSource.setPassword("password"); // create data source proxy - final DataSourceProxy proxy = new DataSourceProxy(dataSource); + final DataSourceProxy proxy = getDataSourceProxy(dataSource); // get fields Field resourceIdField = proxy.getClass().getDeclaredField("resourceId"); @@ -124,4 +169,17 @@ public void getResourceIdTest() throws SQLException, NoSuchFieldException, Illeg jdbcUrlField.set(proxy, jdbcUrl); } } + + // to skip the db & undolog table check + public static DataSourceProxy getDataSourceProxy(DataSource dataSource) { + try (MockedStatic undoLogManagerFactoryMockedStatic = Mockito.mockStatic(UndoLogManagerFactory.class)) { + MySQLUndoLogManager mysqlUndoLogManager = mock(MySQLUndoLogManager.class); + undoLogManagerFactoryMockedStatic.when(() -> UndoLogManagerFactory.getUndoLogManager(anyString())).thenReturn(mysqlUndoLogManager); + + doReturn(true).when(mysqlUndoLogManager).hasUndoLogTable(any(Connection.class)); + + // create data source proxy + return new DataSourceProxy(dataSource); + } + } } diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/PreparedStatementProxyTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/PreparedStatementProxyTest.java index cd7c58cb9df..3ef88b2e1c8 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/PreparedStatementProxyTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/PreparedStatementProxyTest.java @@ -44,6 +44,8 @@ import io.seata.rm.datasource.mock.MockClob; import io.seata.rm.datasource.mock.MockConnection; import io.seata.rm.datasource.mock.MockDriver; +import io.seata.rm.datasource.undo.UndoLogManagerFactory; +import io.seata.rm.datasource.undo.mysql.MySQLUndoLogManager; import io.seata.sqlparser.SQLRecognizerFactory; import io.seata.sqlparser.SqlParserType; import io.seata.sqlparser.druid.DruidDelegatingSQLRecognizerFactory; @@ -54,6 +56,12 @@ import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; +import org.mockito.MockedStatic; +import org.mockito.Mockito; + +import javax.sql.DataSource; + +import static org.mockito.ArgumentMatchers.anyString; /** * @author will @@ -86,8 +94,7 @@ public static void init() throws SQLException { DruidDataSource dataSource = new DruidDataSource(); dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); - - DataSourceProxy dataSourceProxy = new DataSourceProxy(dataSource); + DataSourceProxy dataSourceProxy = DataSourceProxyTest.getDataSourceProxy(dataSource); ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, dataSource.getConnection().getConnection()); diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/StatementProxyTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/StatementProxyTest.java index 8260ef81e7e..54646a9ddc3 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/StatementProxyTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/StatementProxyTest.java @@ -31,6 +31,8 @@ import io.seata.rm.datasource.mock.MockConnection; import io.seata.rm.datasource.mock.MockDriver; +import io.seata.rm.datasource.undo.UndoLogManagerFactory; +import io.seata.rm.datasource.undo.mysql.MySQLUndoLogManager; import io.seata.sqlparser.SQLRecognizerFactory; import io.seata.sqlparser.SqlParserType; import io.seata.sqlparser.druid.DruidDelegatingSQLRecognizerFactory; @@ -44,6 +46,10 @@ import org.junit.jupiter.api.MethodOrderer; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.TestMethodOrder; +import org.mockito.MockedStatic; +import org.mockito.Mockito; + +import static org.mockito.ArgumentMatchers.anyString; /** * @author will @@ -78,7 +84,7 @@ public static void init() throws SQLException { dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); - DataSourceProxy dataSourceProxy = new DataSourceProxy(dataSource); + DataSourceProxy dataSourceProxy = DataSourceProxyTest.getDataSourceProxy(dataSource); ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, dataSource.getConnection().getConnection()); diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/exec/DeleteExecutorTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/exec/DeleteExecutorTest.java index 838e73a3448..b3b5ed10554 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/exec/DeleteExecutorTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/exec/DeleteExecutorTest.java @@ -29,13 +29,23 @@ import com.google.common.collect.Lists; import io.seata.rm.datasource.ConnectionProxy; import io.seata.rm.datasource.DataSourceProxy; +import io.seata.rm.datasource.DataSourceProxyTest; import io.seata.rm.datasource.StatementProxy; import io.seata.rm.datasource.mock.MockDriver; import io.seata.rm.datasource.sql.struct.TableRecords; +import io.seata.rm.datasource.undo.UndoLogManagerFactory; +import io.seata.rm.datasource.undo.mysql.MySQLUndoLogManager; import io.seata.sqlparser.druid.mysql.MySQLDeleteRecognizer; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; +import org.mockito.MockedStatic; +import org.mockito.Mockito; + +import javax.sql.DataSource; + +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.when; /** * @author will @@ -66,7 +76,7 @@ public static void init() { dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); - DataSourceProxy dataSourceProxy = new DataSourceProxy(dataSource); + DataSourceProxy dataSourceProxy = DataSourceProxyTest.getDataSourceProxy(dataSource); try { Field field = dataSourceProxy.getClass().getDeclaredField("dbType"); field.setAccessible(true); @@ -101,4 +111,5 @@ public void testAfterImage() throws SQLException { TableRecords tableRecords = deleteExecutor.beforeImage(); Assertions.assertEquals(0, deleteExecutor.afterImage(tableRecords).size()); } + } diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/exec/MultiExecutorTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/exec/MultiExecutorTest.java index 332bde4985d..980aee46f69 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/exec/MultiExecutorTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/exec/MultiExecutorTest.java @@ -24,6 +24,9 @@ import java.util.Set; import java.util.stream.Collectors; +import io.seata.rm.datasource.DataSourceProxyTest; +import io.seata.rm.datasource.undo.UndoLogManagerFactory; +import io.seata.rm.datasource.undo.mysql.MySQLUndoLogManager; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; @@ -44,6 +47,14 @@ import io.seata.sqlparser.SQLRecognizer; import io.seata.sqlparser.SQLType; import io.seata.sqlparser.util.JdbcConstants; +import org.mockito.MockedStatic; +import org.mockito.Mockito; + +import javax.sql.DataSource; + +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; public class MultiExecutorTest { @@ -73,7 +84,8 @@ public static void init() throws Throwable { dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); - DataSourceProxy dataSourceProxy = new DataSourceProxy(dataSource); + DataSourceProxy dataSourceProxy = DataSourceProxyTest.getDataSourceProxy(dataSource); + try { Field field = dataSourceProxy.getClass().getDeclaredField("dbType"); field.setAccessible(true); diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/exec/PlainExecutorTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/exec/PlainExecutorTest.java index 7a2e545b65c..22b18549ca5 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/exec/PlainExecutorTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/exec/PlainExecutorTest.java @@ -24,6 +24,7 @@ import com.google.common.collect.Lists; import io.seata.rm.datasource.ConnectionProxy; import io.seata.rm.datasource.DataSourceProxy; +import io.seata.rm.datasource.DataSourceProxyTest; import io.seata.rm.datasource.StatementProxy; import io.seata.rm.datasource.mock.MockDriver; import org.junit.jupiter.api.BeforeEach; @@ -56,7 +57,8 @@ public void init() throws SQLException { dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); - DataSourceProxy dataSourceProxy = new DataSourceProxy(dataSource); + DataSourceProxy dataSourceProxy = DataSourceProxyTest.getDataSourceProxy(dataSource); + ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, dataSource.getConnection().getConnection()); MockStatementBase mockStatement = new MockStatement(dataSource.getConnection().getConnection()); StatementProxy statementProxy = new StatementProxy(connectionProxy, mockStatement); diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/exec/SelectForUpdateExecutorTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/exec/SelectForUpdateExecutorTest.java index 46d4ca0f75a..c53d382f1dd 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/exec/SelectForUpdateExecutorTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/exec/SelectForUpdateExecutorTest.java @@ -28,14 +28,21 @@ import io.seata.core.context.RootContext; import io.seata.rm.datasource.ConnectionProxy; import io.seata.rm.datasource.DataSourceProxy; +import io.seata.rm.datasource.DataSourceProxyTest; import io.seata.rm.datasource.StatementProxy; import io.seata.rm.datasource.mock.MockConnectionProxy; import io.seata.rm.datasource.mock.MockDriver; import io.seata.rm.datasource.mock.MockLockConflictConnectionProxy; +import io.seata.rm.datasource.undo.UndoLogManagerFactory; +import io.seata.rm.datasource.undo.mysql.MySQLUndoLogManager; import io.seata.sqlparser.druid.mysql.MySQLSelectForUpdateRecognizer; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; +import org.mockito.MockedStatic; +import org.mockito.Mockito; + +import static org.mockito.ArgumentMatchers.anyString; /** * @author will @@ -69,7 +76,8 @@ public static void init() { dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); - DataSourceProxy dataSourceProxy = new DataSourceProxy(dataSource); + DataSourceProxy dataSourceProxy = DataSourceProxyTest.getDataSourceProxy(dataSource); + try { Field field = dataSourceProxy.getClass().getDeclaredField("dbType"); field.setAccessible(true); diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/exec/UpdateExecutorTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/exec/UpdateExecutorTest.java index c25df6f4e37..973ae530ad1 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/exec/UpdateExecutorTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/exec/UpdateExecutorTest.java @@ -30,13 +30,22 @@ import com.google.common.collect.Lists; import io.seata.rm.datasource.ConnectionProxy; import io.seata.rm.datasource.DataSourceProxy; +import io.seata.rm.datasource.DataSourceProxyTest; import io.seata.rm.datasource.StatementProxy; import io.seata.rm.datasource.mock.MockDriver; import io.seata.rm.datasource.sql.struct.TableRecords; +import io.seata.rm.datasource.undo.UndoLogManagerFactory; +import io.seata.rm.datasource.undo.mysql.MySQLUndoLogManager; import io.seata.sqlparser.druid.mysql.MySQLUpdateRecognizer; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; +import org.mockito.MockedStatic; +import org.mockito.Mockito; + +import javax.sql.DataSource; + +import static org.mockito.ArgumentMatchers.anyString; /** * @author will @@ -68,7 +77,8 @@ public static void init() { dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); - DataSourceProxy dataSourceProxy = new DataSourceProxy(dataSource); + DataSourceProxy dataSourceProxy = DataSourceProxyTest.getDataSourceProxy(dataSource); + try { Field field = dataSourceProxy.getClass().getDeclaredField("dbType"); field.setAccessible(true); diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/exec/UpdateJoinExecutorTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/exec/UpdateJoinExecutorTest.java index 971dfd03373..fbde0a4bd96 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/exec/UpdateJoinExecutorTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/exec/UpdateJoinExecutorTest.java @@ -29,13 +29,20 @@ import com.google.common.collect.Lists; import io.seata.rm.datasource.ConnectionProxy; import io.seata.rm.datasource.DataSourceProxy; +import io.seata.rm.datasource.DataSourceProxyTest; import io.seata.rm.datasource.StatementProxy; import io.seata.rm.datasource.exec.mysql.MySQLUpdateJoinExecutor; import io.seata.rm.datasource.mock.MockDriver; import io.seata.rm.datasource.sql.struct.TableRecords; +import io.seata.rm.datasource.undo.UndoLogManagerFactory; +import io.seata.rm.datasource.undo.mysql.MySQLUndoLogManager; import io.seata.sqlparser.druid.mysql.MySQLUpdateRecognizer; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; +import org.mockito.MockedStatic; +import org.mockito.Mockito; + +import static org.mockito.ArgumentMatchers.anyString; /** * @author renliangyu857 @@ -81,7 +88,7 @@ private StatementProxy mockStatementProxy(List returnValueColumnLabels, dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); - DataSourceProxy dataSourceProxy = new DataSourceProxy(dataSource); + DataSourceProxy dataSourceProxy = DataSourceProxyTest.getDataSourceProxy(dataSource); try { Field field = dataSourceProxy.getClass().getDeclaredField("dbType"); field.setAccessible(true); diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/TableRecordsTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/TableRecordsTest.java index 61714ca7778..bc02c64016a 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/TableRecordsTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/TableRecordsTest.java @@ -15,26 +15,25 @@ */ package io.seata.rm.datasource.sql.struct; -import java.sql.ResultSet; -import java.sql.SQLException; -import java.sql.Types; -import java.util.List; - -import io.seata.rm.datasource.exception.TableMetaException; -import io.seata.sqlparser.struct.TableMeta; -import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - import com.alibaba.druid.mock.MockStatement; import com.alibaba.druid.mock.MockStatementBase; import com.alibaba.druid.pool.DruidDataSource; import com.google.common.collect.Lists; - import io.seata.common.exception.ShouldNeverHappenException; import io.seata.rm.datasource.DataSourceProxy; +import io.seata.rm.datasource.DataSourceProxyTest; +import io.seata.rm.datasource.exception.TableMetaException; import io.seata.rm.datasource.mock.MockDriver; +import io.seata.sqlparser.struct.TableMeta; import io.seata.sqlparser.util.JdbcConstants; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Types; +import java.util.List; /** * the table records test @@ -102,8 +101,9 @@ public void testPkRow() throws SQLException { DruidDataSource dataSource = new DruidDataSource(); dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); + MockStatementBase mockStatement = new MockStatement(dataSource.getConnection().getConnection()); - DataSourceProxy proxy = new DataSourceProxy(dataSource); + DataSourceProxy proxy = DataSourceProxyTest.getDataSourceProxy(dataSource); TableMeta tableMeta = TableMetaCacheFactory.getTableMetaCache(JdbcConstants.MYSQL).getTableMeta(proxy.getPlainConnection(), "table_records_test", proxy.getResourceId()); @@ -122,7 +122,7 @@ public void testBuildRecords() throws SQLException { dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); MockStatementBase mockStatement = new MockStatement(dataSource.getConnection().getConnection()); - DataSourceProxy proxy = new DataSourceProxy(dataSource); + DataSourceProxy proxy = DataSourceProxyTest.getDataSourceProxy(dataSource); TableMeta tableMeta = TableMetaCacheFactory.getTableMetaCache(JdbcConstants.MYSQL).getTableMeta(proxy.getPlainConnection(), "table_records_test", proxy.getResourceId()); @@ -141,7 +141,7 @@ public void testBuildRecordsNewFeild() throws SQLException { dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); MockStatementBase mockStatement = new MockStatement(dataSource.getConnection().getConnection()); - DataSourceProxy proxy = new DataSourceProxy(dataSource); + DataSourceProxy proxy = DataSourceProxyTest.getDataSourceProxy(dataSource); TableMeta tableMeta = TableMetaCacheFactory.getTableMetaCache(JdbcConstants.MYSQL).getTableMeta(proxy.getPlainConnection(), "table_records_test", proxy.getResourceId()); diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/DmTableMetaCacheTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/DmTableMetaCacheTest.java index e4319ea5b3f..8973b130516 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/DmTableMetaCacheTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/DmTableMetaCacheTest.java @@ -17,6 +17,7 @@ import com.alibaba.druid.pool.DruidDataSource; import io.seata.rm.datasource.DataSourceProxy; +import io.seata.rm.datasource.DataSourceProxyTest; import io.seata.rm.datasource.mock.MockDriver; import io.seata.rm.datasource.sql.struct.TableMetaCacheFactory; import io.seata.sqlparser.struct.TableMeta; @@ -65,7 +66,7 @@ public void getTableMetaTest() throws SQLException { dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); - DataSourceProxy proxy = new DataSourceProxy(dataSource); + DataSourceProxy proxy = DataSourceProxyTest.getDataSourceProxy(dataSource); TableMetaCache tableMetaCache = TableMetaCacheFactory.getTableMetaCache(JdbcConstants.DM); diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/MariadbTableMetaCacheTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/MariadbTableMetaCacheTest.java index a13c9991c8c..01144502bc9 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/MariadbTableMetaCacheTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/MariadbTableMetaCacheTest.java @@ -19,6 +19,9 @@ import java.sql.Types; import java.util.Collections; +import io.seata.rm.datasource.DataSourceProxyTest; +import io.seata.rm.datasource.undo.UndoLogManagerFactory; +import io.seata.rm.datasource.undo.mysql.MySQLUndoLogManager; import io.seata.sqlparser.struct.ColumnMeta; import io.seata.sqlparser.struct.IndexMeta; import io.seata.sqlparser.struct.IndexType; @@ -34,6 +37,10 @@ import io.seata.rm.datasource.mock.MockDriver; import io.seata.rm.datasource.sql.struct.TableMetaCacheFactory; import io.seata.sqlparser.util.JdbcConstants; +import org.mockito.MockedStatic; +import org.mockito.Mockito; + +import static org.mockito.ArgumentMatchers.anyString; /** * The table meta fetch test. @@ -84,7 +91,7 @@ public void getTableMetaTest_0() throws SQLException { dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); - DataSourceProxy proxy = new DataSourceProxy(dataSource); + DataSourceProxy proxy = DataSourceProxyTest.getDataSourceProxy(dataSource); TableMeta tableMeta = getTableMetaCache().getTableMeta(proxy.getPlainConnection(), "mt1", proxy.getResourceId()); @@ -133,7 +140,7 @@ public void refreshTest_0() throws SQLException { druidDataSource.setUrl("jdbc:mock:xxx"); druidDataSource.setDriver(mockDriver); - DataSourceProxy dataSourceProxy = new DataSourceProxy(druidDataSource); + DataSourceProxy dataSourceProxy = DataSourceProxyTest.getDataSourceProxy(druidDataSource); TableMeta tableMeta = getTableMetaCache().getTableMeta(dataSourceProxy.getPlainConnection(), "t1", dataSourceProxy.getResourceId()); diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/MysqlTableMetaCacheTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/MysqlTableMetaCacheTest.java index 56928aa6d70..0dbe2400ef7 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/MysqlTableMetaCacheTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/MysqlTableMetaCacheTest.java @@ -19,6 +19,9 @@ import java.sql.Types; import java.util.Collections; +import io.seata.rm.datasource.DataSourceProxyTest; +import io.seata.rm.datasource.undo.UndoLogManagerFactory; +import io.seata.rm.datasource.undo.mysql.MySQLUndoLogManager; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; @@ -34,6 +37,13 @@ import io.seata.sqlparser.struct.TableMetaCache; import io.seata.rm.datasource.sql.struct.TableMetaCacheFactory; import io.seata.sqlparser.util.JdbcConstants; +import org.mockito.MockedStatic; +import org.mockito.Mockito; + +import javax.sql.DataSource; + +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.mock; /** * The table meta fetch test. @@ -84,7 +94,7 @@ public void getTableMetaTest_0() throws SQLException { dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); - DataSourceProxy proxy = new DataSourceProxy(dataSource); + DataSourceProxy proxy = DataSourceProxyTest.getDataSourceProxy(dataSource); TableMeta tableMeta = getTableMetaCache().getTableMeta(proxy.getPlainConnection(), "mt1", proxy.getResourceId()); @@ -133,7 +143,7 @@ public void refreshTest_0() throws SQLException { druidDataSource.setUrl("jdbc:mock:xxx"); druidDataSource.setDriver(mockDriver); - DataSourceProxy dataSourceProxy = new DataSourceProxy(druidDataSource); + DataSourceProxy dataSourceProxy = DataSourceProxyTest.getDataSourceProxy(druidDataSource); TableMeta tableMeta = getTableMetaCache().getTableMeta(dataSourceProxy.getPlainConnection(), "t1", dataSourceProxy.getResourceId()); diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/OracleTableMetaCacheTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/OracleTableMetaCacheTest.java index 8d3aa2abccd..fd7877acac9 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/OracleTableMetaCacheTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/OracleTableMetaCacheTest.java @@ -18,6 +18,9 @@ import java.sql.SQLException; import java.sql.Types; +import io.seata.rm.datasource.DataSourceProxyTest; +import io.seata.rm.datasource.undo.UndoLogManagerFactory; +import io.seata.rm.datasource.undo.mysql.MySQLUndoLogManager; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; @@ -29,6 +32,10 @@ import io.seata.sqlparser.struct.TableMetaCache; import io.seata.rm.datasource.sql.struct.TableMetaCacheFactory; import io.seata.sqlparser.util.JdbcConstants; +import org.mockito.MockedStatic; +import org.mockito.Mockito; + +import static org.mockito.ArgumentMatchers.anyString; /** * @author will.zjw @@ -65,7 +72,7 @@ public void getTableMetaTest() throws SQLException { dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); - DataSourceProxy proxy = new DataSourceProxy(dataSource); + DataSourceProxy proxy = DataSourceProxyTest.getDataSourceProxy(dataSource); TableMetaCache tableMetaCache = TableMetaCacheFactory.getTableMetaCache(JdbcConstants.ORACLE); diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/PostgresqlTableMetaCacheTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/PostgresqlTableMetaCacheTest.java index 2098629e824..bf1a116c47f 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/PostgresqlTableMetaCacheTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/PostgresqlTableMetaCacheTest.java @@ -18,6 +18,9 @@ import java.sql.SQLException; import java.sql.Types; +import io.seata.rm.datasource.DataSourceProxyTest; +import io.seata.rm.datasource.undo.UndoLogManagerFactory; +import io.seata.rm.datasource.undo.mysql.MySQLUndoLogManager; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; @@ -29,6 +32,12 @@ import io.seata.sqlparser.struct.TableMetaCache; import io.seata.rm.datasource.sql.struct.TableMetaCacheFactory; import io.seata.sqlparser.util.JdbcConstants; +import org.mockito.MockedStatic; +import org.mockito.Mockito; + +import javax.sql.DataSource; + +import static org.mockito.ArgumentMatchers.anyString; /** * @author will.zjw @@ -65,7 +74,7 @@ public void getTableMetaTest() throws SQLException { dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); - DataSourceProxy proxy = new DataSourceProxy(dataSource); + DataSourceProxy proxy = DataSourceProxyTest.getDataSourceProxy(dataSource); TableMetaCache tableMetaCache = TableMetaCacheFactory.getTableMetaCache(JdbcConstants.POSTGRESQL); diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/SqlServerTableMetaCacheTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/SqlServerTableMetaCacheTest.java index cb0b49e2f79..4cb0f26d85c 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/SqlServerTableMetaCacheTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/sql/struct/cache/SqlServerTableMetaCacheTest.java @@ -22,7 +22,10 @@ import com.alibaba.druid.pool.DruidDataSource; import io.seata.common.exception.ShouldNeverHappenException; import io.seata.rm.datasource.DataSourceProxy; +import io.seata.rm.datasource.DataSourceProxyTest; import io.seata.rm.datasource.mock.MockDriver; +import io.seata.rm.datasource.undo.UndoLogManagerFactory; +import io.seata.rm.datasource.undo.mysql.MySQLUndoLogManager; import io.seata.sqlparser.struct.ColumnMeta; import io.seata.sqlparser.struct.IndexMeta; import io.seata.sqlparser.struct.IndexType; @@ -32,6 +35,13 @@ import io.seata.sqlparser.util.JdbcConstants; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; +import org.mockito.MockedStatic; +import org.mockito.Mockito; + +import javax.sql.DataSource; + +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.mock; /** * @author GoodBoyCoder @@ -82,7 +92,7 @@ public void getTableMetaTest_0() throws SQLException { dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); - DataSourceProxy proxy = new DataSourceProxy(dataSource); + DataSourceProxy proxy = DataSourceProxyTest.getDataSourceProxy(dataSource); TableMeta tableMeta = getTableMetaCache().getTableMeta(proxy.getPlainConnection(), "m.mt1", proxy.getResourceId()); diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/undo/BaseH2Test.java b/rm-datasource/src/test/java/io/seata/rm/datasource/undo/BaseH2Test.java index 9a84c5e08e5..412cc06bbbb 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/undo/BaseH2Test.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/undo/BaseH2Test.java @@ -18,6 +18,8 @@ import io.seata.common.util.IOUtil; import io.seata.rm.datasource.ConnectionProxy; import io.seata.rm.datasource.DataSourceProxy; +import io.seata.rm.datasource.DataSourceProxyTest; +import io.seata.rm.datasource.undo.mysql.MySQLUndoLogManager; import io.seata.sqlparser.struct.ColumnMeta; import io.seata.rm.datasource.sql.struct.Field; import io.seata.rm.datasource.sql.struct.KeyType; @@ -29,14 +31,17 @@ import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; +import org.mockito.MockedStatic; import org.mockito.Mockito; +import javax.sql.DataSource; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.sql.Types; import java.util.Arrays; +import static org.mockito.ArgumentMatchers.anyString; /** * @author Geng Zhang @@ -58,7 +63,8 @@ public static void start() throws SQLException { dataSource.setUrl("jdbc:h2:./db_store/test_undo"); dataSource.setUsername("sa"); dataSource.setPassword(""); - dataSourceProxy = new DataSourceProxy(dataSource); + dataSourceProxy = DataSourceProxyTest.getDataSourceProxy(dataSource); + connection = dataSourceProxy.getConnection(); tableMeta = mockTableMeta(); diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/undo/mariadb/MariadbUndoLogManagerTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/undo/mariadb/MariadbUndoLogManagerTest.java index 9af77f5eb63..a80799cdbe6 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/undo/mariadb/MariadbUndoLogManagerTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/undo/mariadb/MariadbUndoLogManagerTest.java @@ -25,6 +25,8 @@ import java.util.Date; import java.util.List; +import io.seata.rm.datasource.DataSourceProxyTest; +import io.seata.rm.datasource.undo.*; import io.seata.sqlparser.struct.TableMeta; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeAll; @@ -42,11 +44,6 @@ import io.seata.rm.datasource.mock.MockDriver; import io.seata.rm.datasource.sql.struct.Row; import io.seata.rm.datasource.sql.struct.TableRecords; -import io.seata.rm.datasource.undo.AbstractUndoLogManager; -import io.seata.rm.datasource.undo.BranchUndoLog; -import io.seata.rm.datasource.undo.SQLUndoLog; -import io.seata.rm.datasource.undo.UndoLogParser; -import io.seata.rm.datasource.undo.UndoLogParserFactory; import io.seata.rm.datasource.undo.mysql.MySQLUndoLogManager; import io.seata.rm.datasource.undo.parser.JacksonUndoLogParser; import io.seata.sqlparser.SQLRecognizerFactory; @@ -56,6 +53,13 @@ import io.seata.sqlparser.druid.SQLOperateRecognizerHolder; import io.seata.sqlparser.druid.SQLOperateRecognizerHolderFactory; import io.seata.sqlparser.util.JdbcConstants; +import org.mockito.MockedStatic; +import org.mockito.Mockito; + +import javax.sql.DataSource; + +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.when; /** * @author funkye @@ -100,7 +104,8 @@ public void init() throws SQLException { dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); - dataSourceProxy = new DataSourceProxy(dataSource); + dataSourceProxy = DataSourceProxyTest.getDataSourceProxy(dataSource); + connectionProxy = new ConnectionProxy(dataSourceProxy, dataSource.getConnection().getConnection()); undoLogManager = new MariadbUndoLogManager(); tableMeta = new TableMeta(); diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/undo/mysql/MySQLUndoLogManagerTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/undo/mysql/MySQLUndoLogManagerTest.java index 367dc94a82e..aa6ceeb168a 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/undo/mysql/MySQLUndoLogManagerTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/undo/mysql/MySQLUndoLogManagerTest.java @@ -33,15 +33,12 @@ import io.seata.rm.datasource.ConnectionContext; import io.seata.rm.datasource.ConnectionProxy; import io.seata.rm.datasource.DataSourceProxy; +import io.seata.rm.datasource.DataSourceProxyTest; import io.seata.rm.datasource.mock.MockDriver; import io.seata.rm.datasource.sql.struct.Row; +import io.seata.rm.datasource.undo.*; import io.seata.sqlparser.struct.TableMeta; import io.seata.rm.datasource.sql.struct.TableRecords; -import io.seata.rm.datasource.undo.AbstractUndoLogManager; -import io.seata.rm.datasource.undo.BranchUndoLog; -import io.seata.rm.datasource.undo.SQLUndoLog; -import io.seata.rm.datasource.undo.UndoLogParser; -import io.seata.rm.datasource.undo.UndoLogParserFactory; import io.seata.rm.datasource.undo.parser.JacksonUndoLogParser; import io.seata.sqlparser.SQLRecognizerFactory; import io.seata.sqlparser.SQLType; @@ -54,6 +51,12 @@ import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.mockito.MockedStatic; +import org.mockito.Mockito; + +import javax.sql.DataSource; + +import static org.mockito.ArgumentMatchers.anyString; /** * @author will @@ -98,7 +101,8 @@ public void init() throws SQLException { dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); - dataSourceProxy = new DataSourceProxy(dataSource); + dataSourceProxy = DataSourceProxyTest.getDataSourceProxy(dataSource); + connectionProxy = new ConnectionProxy(dataSourceProxy, dataSource.getConnection().getConnection()); undoLogManager = new MySQLUndoLogManager(); tableMeta = new TableMeta(); diff --git a/rm-datasource/src/test/java/io/seata/rm/datasource/undo/polardbx/PolarDBXUndoLogManagerTest.java b/rm-datasource/src/test/java/io/seata/rm/datasource/undo/polardbx/PolarDBXUndoLogManagerTest.java index e80575b7e09..cb8b2a41a76 100644 --- a/rm-datasource/src/test/java/io/seata/rm/datasource/undo/polardbx/PolarDBXUndoLogManagerTest.java +++ b/rm-datasource/src/test/java/io/seata/rm/datasource/undo/polardbx/PolarDBXUndoLogManagerTest.java @@ -32,15 +32,13 @@ import io.seata.rm.datasource.ConnectionContext; import io.seata.rm.datasource.ConnectionProxy; import io.seata.rm.datasource.DataSourceProxy; +import io.seata.rm.datasource.DataSourceProxyTest; import io.seata.rm.datasource.mock.MockDriver; import io.seata.rm.datasource.sql.struct.Row; import io.seata.rm.datasource.sql.struct.TableRecords; -import io.seata.rm.datasource.undo.AbstractUndoLogManager; -import io.seata.rm.datasource.undo.BranchUndoLog; -import io.seata.rm.datasource.undo.SQLUndoLog; -import io.seata.rm.datasource.undo.UndoLogParser; -import io.seata.rm.datasource.undo.UndoLogParserFactory; +import io.seata.rm.datasource.undo.*; +import io.seata.rm.datasource.undo.mysql.MySQLUndoLogManager; import io.seata.rm.datasource.undo.parser.JacksonUndoLogParser; import io.seata.sqlparser.SQLType; import io.seata.sqlparser.druid.SQLOperateRecognizerHolder; @@ -51,6 +49,12 @@ import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.mockito.MockedStatic; +import org.mockito.Mockito; + +import javax.sql.DataSource; + +import static org.mockito.ArgumentMatchers.anyString; /** * Undo log manager test for PolarDB-X @@ -95,7 +99,7 @@ public void init() throws SQLException { dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(mockDriver); - dataSourceProxy = new DataSourceProxy(dataSource); + dataSourceProxy = DataSourceProxyTest.getDataSourceProxy(dataSource); connectionProxy = new ConnectionProxy(dataSourceProxy, dataSource.getConnection().getConnection()); undoLogManager = new PolarDBXUndoLogManager(); tableMeta = new TableMeta(); From c5761c7ae700a594c0cbf827ab5ed028e31ebb72 Mon Sep 17 00:00:00 2001 From: laywin Date: Sun, 26 Nov 2023 13:06:14 +0800 Subject: [PATCH 12/12] import optimize --- core/src/main/java/io/seata/core/constants/DBType.java | 2 -- .../src/main/java/io/seata/rm/datasource/DataSourceProxy.java | 1 - 2 files changed, 3 deletions(-) diff --git a/core/src/main/java/io/seata/core/constants/DBType.java b/core/src/main/java/io/seata/core/constants/DBType.java index 2a3093e4c63..a0171474033 100644 --- a/core/src/main/java/io/seata/core/constants/DBType.java +++ b/core/src/main/java/io/seata/core/constants/DBType.java @@ -17,8 +17,6 @@ import io.seata.common.util.StringUtils; -import java.util.Optional; - /** * database type * diff --git a/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java b/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java index aa186b3d818..295a22e77b5 100644 --- a/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java +++ b/rm-datasource/src/main/java/io/seata/rm/datasource/DataSourceProxy.java @@ -26,7 +26,6 @@ import io.seata.common.Constants; import io.seata.common.loader.EnhancedServiceNotFoundException; import io.seata.config.ConfigurationFactory; -import io.seata.core.constants.DBType; import io.seata.core.context.RootContext; import io.seata.core.model.BranchType; import io.seata.core.model.Resource;