You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@seata.apache.org by "WangzJi (via GitHub)" <gi...@apache.org> on 2025/11/17 06:49:07 UTC
[PR] test: improve test coverage for rm-datasource [incubator-seata]
WangzJi opened a new pull request, #7788:
URL: https://github.com/apache/incubator-seata/pull/7788
<!--
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<!-- Please make sure you have read and understood the contributing guidelines -->
- [ ] I have read the [CONTRIBUTING.md](https://github.com/apache/incubator-seata/blob/2.x/CONTRIBUTING.md) guidelines.
- [ ] I have registered the PR [changes](https://github.com/apache/incubator-seata/tree/2.x/changes).
### Ⅰ. Describe what this PR did
### Ⅱ. Does this pull request fix one issue?
<!-- If that, add "fixes #xxx" below in the next line, for example, fixes #97. -->
### Ⅲ. Why don't you add test cases (unit test/integration test)?
### Ⅳ. Describe how to verify it
### Ⅴ. Special notes for reviews
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@seata.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: notifications-unsubscribe@seata.apache.org
For additional commands, e-mail: notifications-help@seata.apache.org
Re: [PR] test: improve test coverage for rm-datasource [incubator-seata]
Posted by "Copilot (via GitHub)" <gi...@apache.org>.
Copilot commented on code in PR #7788:
URL: https://github.com/apache/incubator-seata/pull/7788#discussion_r2540784857
##########
rm-datasource/src/main/java/org/apache/seata/rm/datasource/sql/struct/cache/AbstractTableMetaCache.java:
##########
@@ -87,13 +87,16 @@ public TableMeta getTableMeta(final Connection connection, final String tableNam
public void refresh(final Connection connection, String resourceId) {
ConcurrentMap<String, TableMeta> tableMetaMap = TABLE_META_CACHE.asMap();
for (Map.Entry<String, TableMeta> entry : tableMetaMap.entrySet()) {
- String key = getCacheKey(connection, entry.getValue().getOriginalTableName(), resourceId);
+ TableMeta meta = entry.getValue();
+ String tableNameForKey = StringUtils.isBlank(meta.getOriginalTableName())
+ ? meta.getTableName()
+ : meta.getOriginalTableName();
+
+ String key = getCacheKey(connection, tableNameForKey, resourceId);
if (entry.getKey().equals(key)) {
try {
- String freshTableName = StringUtils.isBlank(entry.getValue().getOriginalTableName())
- ? entry.getValue().getTableName()
- : entry.getValue().getOriginalTableName();
- TableMeta tableMeta = fetchSchema(connection, freshTableName);
+ // 直接复用 tableNameForKey，无需再次判断
Review Comment:
The comment is in Chinese. For consistency with the rest of the codebase, comments should be in English. Consider changing "直接复用 tableNameForKey，无需再次判断" to "Reuse tableNameForKey directly, no need to check again".
```suggestion
// Reuse tableNameForKey directly, no need to check again
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
public void testGetContext() throws Exception {
try (ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null))) {
Assertions.assertNotNull(connectionProxy.getContext());
}
}
@Test
public void testBindXid() throws Exception {
try (ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null))) {
connectionProxy.bind(TEST_XID);
Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
}
}
@Test
public void testSetGlobalLockRequire() throws Exception {
try (ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null))) {
connectionProxy.setGlobalLockRequire(true);
Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
connectionProxy.setGlobalLockRequire(false);
Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
}
}
@Test
public void testAppendUndoLog() throws Exception {
try (ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null))) {
SQLUndoLog undoLog = new SQLUndoLog();
connectionProxy.appendUndoLog(undoLog);
Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, mockConnection);
Assertions.assertNotNull(connectionProxy.getContext());
}
@Test
public void testBindXid() {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, mockConnection);
connectionProxy.bind(TEST_XID);
Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
}
@Test
public void testSetGlobalLockRequire() {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, mockConnection);
connectionProxy.setGlobalLockRequire(true);
Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
connectionProxy.setGlobalLockRequire(false);
Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
}
@Test
public void testAppendUndoLog() {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, mockConnection);
SQLUndoLog undoLog = new SQLUndoLog();
connectionProxy.appendUndoLog(undoLog);
Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
Review Comment:
This MockConnection is not always closed on method exit.
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithGlobalLockRequireTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithoutTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.commit();
+
+ Assertions.assertNull(connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void commitWithSQLExceptionTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+ Mockito.doNothing().when(mockConnection).rollback();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ connectionProxy.setAutoCommit(false);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(mockConnection).rollback();
+ }
+
+ @Test
+ public void rollbackTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.rollback();
+
+ Assertions.assertNull(connectionProxy.getContext().getBranchId());
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
connectionProxy.setAutoCommit(false);
connectionProxy.rollback();
Assertions.assertNull(connectionProxy.getContext().getBranchId());
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithGlobalLockRequireTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithoutTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.commit();
+
+ Assertions.assertNull(connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void commitWithSQLExceptionTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+ Mockito.doNothing().when(mockConnection).rollback();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ connectionProxy.setAutoCommit(false);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(mockConnection).rollback();
+ }
+
+ @Test
+ public void rollbackTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.rollback();
+
+ Assertions.assertNull(connectionProxy.getContext().getBranchId());
+ }
+
+ @Test
+ public void rollbackWithBranchRegisteredTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.getContext().setBranchId(123456L);
+ connectionProxy.rollback();
+
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(123456L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void registerSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey)))
+ .thenReturn(789L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void registerWithNoUndoLogTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void registerWithNoLockKeyTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void reportSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(999L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(999L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.branchRegister(
Mockito.eq(BranchType.AT),
Mockito.anyString(),
Mockito.isNull(),
Mockito.anyString(),
Mockito.anyString(),
Mockito.anyString()))
.thenReturn(999L);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.setAutoCommit(false);
connectionProxy.bind(TEST_XID);
SQLUndoLog sqlUndoLog = new SQLUndoLog();
TableRecords beforeImage = new TableRecords();
beforeImage.add(new Row());
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.appendUndoLog(sqlUndoLog);
connectionProxy.appendLockKey(lockKey);
connectionProxy.commit();
if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
Mockito.verify(rm)
.branchReport(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_XID),
Mockito.eq(999L),
Mockito.eq(BranchStatus.PhaseOne_Done),
Mockito.isNull());
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithGlobalLockRequireTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithoutTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.commit();
+
+ Assertions.assertNull(connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void commitWithSQLExceptionTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+ Mockito.doNothing().when(mockConnection).rollback();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ connectionProxy.setAutoCommit(false);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(mockConnection).rollback();
+ }
+
+ @Test
+ public void rollbackTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.rollback();
+
+ Assertions.assertNull(connectionProxy.getContext().getBranchId());
+ }
+
+ @Test
+ public void rollbackWithBranchRegisteredTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.getContext().setBranchId(123456L);
+ connectionProxy.rollback();
+
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(123456L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void registerSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey)))
+ .thenReturn(789L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void registerWithNoUndoLogTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void registerWithNoLockKeyTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void reportSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(999L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(999L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void reportFailureTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(888L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(rm, Mockito.times(2))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(888L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void reportWithRetryTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(777L);
+ Mockito.doThrow(new TransactionException("Report failed"))
+ .doNothing()
+ .when(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm, Mockito.atLeast(1))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void setAutoCommitToTrueInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(555L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.setAutoCommit(true);
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ Assertions.assertTrue(mockConnection.getAutoCommit());
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.branchRegister(
Mockito.eq(BranchType.AT),
Mockito.anyString(),
Mockito.isNull(),
Mockito.anyString(),
Mockito.anyString(),
Mockito.anyString()))
.thenReturn(555L);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.setAutoCommit(false);
connectionProxy.bind(TEST_XID);
SQLUndoLog sqlUndoLog = new SQLUndoLog();
TableRecords beforeImage = new TableRecords();
beforeImage.add(new Row());
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.appendUndoLog(sqlUndoLog);
connectionProxy.appendLockKey(lockKey);
connectionProxy.setAutoCommit(true);
Mockito.verify(rm)
.branchRegister(
Mockito.eq(BranchType.AT),
Mockito.anyString(),
Mockito.isNull(),
Mockito.eq(TEST_XID),
Mockito.anyString(),
Mockito.eq(lockKey));
Assertions.assertTrue(mockConnection.getAutoCommit());
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithGlobalLockRequireTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithoutTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.commit();
+
+ Assertions.assertNull(connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void commitWithSQLExceptionTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+ Mockito.doNothing().when(mockConnection).rollback();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ connectionProxy.setAutoCommit(false);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(mockConnection).rollback();
+ }
+
+ @Test
+ public void rollbackTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.rollback();
+
+ Assertions.assertNull(connectionProxy.getContext().getBranchId());
+ }
+
+ @Test
+ public void rollbackWithBranchRegisteredTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.getContext().setBranchId(123456L);
+ connectionProxy.rollback();
+
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(123456L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void registerSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey)))
+ .thenReturn(789L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void registerWithNoUndoLogTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void registerWithNoLockKeyTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void reportSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(999L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(999L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void reportFailureTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(888L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(rm, Mockito.times(2))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(888L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void reportWithRetryTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(777L);
+ Mockito.doThrow(new TransactionException("Report failed"))
+ .doNothing()
+ .when(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm, Mockito.atLeast(1))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void setAutoCommitToTrueInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(555L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.setAutoCommit(true);
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ Assertions.assertTrue(mockConnection.getAutoCommit());
+ }
+
+ @Test
+ public void setAutoCommitToTrueWithGlobalLockTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.setAutoCommit(true);
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ Assertions.assertTrue(mockConnection.getAutoCommit());
+ }
+
+ @Test
+ public void checkLockWithRealLockKeysTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.checkLock(lockKey);
+
+ Mockito.verify(rm)
+ .lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void checkLockWithConflictTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(false);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ Assertions.assertThrows(LockConflictException.class, () -> connectionProxy.checkLock(lockKey));
+ }
+
+ @Test
+ public void lockQueryReturnsTrueTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ boolean result = connectionProxy.lockQuery(lockKey);
+
+ Assertions.assertTrue(result);
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try {
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.lockQuery(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.eq(TEST_XID),
Mockito.eq(lockKey)))
.thenReturn(true);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.bind(TEST_XID);
connectionProxy.checkLock(lockKey);
Mockito.verify(rm)
.lockQuery(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.eq(TEST_XID),
Mockito.eq(lockKey));
} finally {
mockConnection.close();
}
}
@Test
public void checkLockWithConflictTest() throws Exception {
MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
try {
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.lockQuery(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.eq(TEST_XID),
Mockito.eq(lockKey)))
.thenReturn(false);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.bind(TEST_XID);
Assertions.assertThrows(LockConflictException.class, () -> connectionProxy.checkLock(lockKey));
} finally {
mockConnection.close();
}
}
@Test
public void lockQueryReturnsTrueTest() throws Exception {
MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
try {
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.lockQuery(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.eq(TEST_XID),
Mockito.eq(lockKey)))
.thenReturn(true);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.bind(TEST_XID);
boolean result = connectionProxy.lockQuery(lockKey);
Assertions.assertTrue(result);
} finally {
mockConnection.close();
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithGlobalLockRequireTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithoutTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.commit();
+
+ Assertions.assertNull(connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void commitWithSQLExceptionTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+ Mockito.doNothing().when(mockConnection).rollback();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ connectionProxy.setAutoCommit(false);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(mockConnection).rollback();
+ }
+
+ @Test
+ public void rollbackTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.rollback();
+
+ Assertions.assertNull(connectionProxy.getContext().getBranchId());
+ }
+
+ @Test
+ public void rollbackWithBranchRegisteredTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.getContext().setBranchId(123456L);
+ connectionProxy.rollback();
+
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(123456L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void registerSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey)))
+ .thenReturn(789L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void registerWithNoUndoLogTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void registerWithNoLockKeyTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void reportSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(999L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(999L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void reportFailureTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(888L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(rm, Mockito.times(2))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(888L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void reportWithRetryTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(777L);
+ Mockito.doThrow(new TransactionException("Report failed"))
+ .doNothing()
+ .when(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm, Mockito.atLeast(1))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void setAutoCommitToTrueInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(555L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.setAutoCommit(true);
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ Assertions.assertTrue(mockConnection.getAutoCommit());
+ }
+
+ @Test
+ public void setAutoCommitToTrueWithGlobalLockTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.setAutoCommit(true);
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ Assertions.assertTrue(mockConnection.getAutoCommit());
+ }
+
+ @Test
+ public void checkLockWithRealLockKeysTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.checkLock(lockKey);
+
+ Mockito.verify(rm)
+ .lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void checkLockWithConflictTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(false);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ Assertions.assertThrows(LockConflictException.class, () -> connectionProxy.checkLock(lockKey));
+ }
+
+ @Test
+ public void lockQueryReturnsTrueTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ boolean result = connectionProxy.lockQuery(lockKey);
+
+ Assertions.assertTrue(result);
+ }
+
+ @Test
+ public void lockQueryReturnsFalseTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(false);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ boolean result = connectionProxy.lockQuery(lockKey);
+
+ Assertions.assertFalse(result);
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.lockQuery(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.eq(TEST_XID),
Mockito.eq(lockKey)))
.thenReturn(false);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.bind(TEST_XID);
Assertions.assertThrows(LockConflictException.class, () -> connectionProxy.checkLock(lockKey));
}
}
@Test
public void lockQueryReturnsTrueTest() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.lockQuery(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.eq(TEST_XID),
Mockito.eq(lockKey)))
.thenReturn(true);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.bind(TEST_XID);
boolean result = connectionProxy.lockQuery(lockKey);
Assertions.assertTrue(result);
}
}
@Test
public void lockQueryReturnsFalseTest() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.lockQuery(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.eq(TEST_XID),
Mockito.eq(lockKey)))
.thenReturn(false);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.bind(TEST_XID);
boolean result = connectionProxy.lockQuery(lockKey);
Assertions.assertFalse(result);
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithGlobalLockRequireTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithoutTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.commit();
+
+ Assertions.assertNull(connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void commitWithSQLExceptionTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+ Mockito.doNothing().when(mockConnection).rollback();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ connectionProxy.setAutoCommit(false);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(mockConnection).rollback();
+ }
+
+ @Test
+ public void rollbackTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.rollback();
+
+ Assertions.assertNull(connectionProxy.getContext().getBranchId());
+ }
+
+ @Test
+ public void rollbackWithBranchRegisteredTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.getContext().setBranchId(123456L);
+ connectionProxy.rollback();
+
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(123456L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void registerSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey)))
+ .thenReturn(789L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void registerWithNoUndoLogTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void registerWithNoLockKeyTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void reportSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(999L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(999L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void reportFailureTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(888L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(rm, Mockito.times(2))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(888L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void reportWithRetryTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(777L);
+ Mockito.doThrow(new TransactionException("Report failed"))
+ .doNothing()
+ .when(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm, Mockito.atLeast(1))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void setAutoCommitToTrueInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(555L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.setAutoCommit(true);
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ Assertions.assertTrue(mockConnection.getAutoCommit());
+ }
+
+ @Test
+ public void setAutoCommitToTrueWithGlobalLockTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.setAutoCommit(true);
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ Assertions.assertTrue(mockConnection.getAutoCommit());
+ }
+
+ @Test
+ public void checkLockWithRealLockKeysTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.checkLock(lockKey);
+
+ Mockito.verify(rm)
+ .lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void checkLockWithConflictTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(false);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ Assertions.assertThrows(LockConflictException.class, () -> connectionProxy.checkLock(lockKey));
+ }
+
+ @Test
+ public void lockQueryReturnsTrueTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ boolean result = connectionProxy.lockQuery(lockKey);
+
+ Assertions.assertTrue(result);
+ }
+
+ @Test
+ public void lockQueryReturnsFalseTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(false);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ boolean result = connectionProxy.lockQuery(lockKey);
+
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void setSavepointTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ Savepoint savepoint = connectionProxy.setSavepoint();
+
+ Assertions.assertNotNull(savepoint);
+ }
+
+ @Test
+ public void setSavepointWithNameTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ String savepointName = "sp1";
+ Savepoint savepoint = connectionProxy.setSavepoint(savepointName);
+
+ Assertions.assertNotNull(savepoint);
+ }
+
+ @Test
+ public void rollbackToSavepointTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ Savepoint savepoint = connectionProxy.setSavepoint();
+ Assertions.assertNotNull(savepoint);
+
+ connectionProxy.rollback(savepoint);
+
+ Assertions.assertNotNull(connectionProxy.getContext());
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.lockQuery(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.eq(TEST_XID),
Mockito.eq(lockKey)))
.thenReturn(true);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.bind(TEST_XID);
boolean result = connectionProxy.lockQuery(lockKey);
Assertions.assertTrue(result);
}
}
@Test
public void lockQueryReturnsFalseTest() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.lockQuery(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.eq(TEST_XID),
Mockito.eq(lockKey)))
.thenReturn(false);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.bind(TEST_XID);
boolean result = connectionProxy.lockQuery(lockKey);
Assertions.assertFalse(result);
}
}
@Test
public void setSavepointTest() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
Savepoint savepoint = connectionProxy.setSavepoint();
Assertions.assertNotNull(savepoint);
}
}
@Test
public void setSavepointWithNameTest() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
String savepointName = "sp1";
Savepoint savepoint = connectionProxy.setSavepoint(savepointName);
Assertions.assertNotNull(savepoint);
}
}
@Test
public void rollbackToSavepointTest() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
Savepoint savepoint = connectionProxy.setSavepoint();
Assertions.assertNotNull(savepoint);
connectionProxy.rollback(savepoint);
Assertions.assertNotNull(connectionProxy.getContext());
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
public void testBindXid() throws Exception {
try (ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null))) {
connectionProxy.bind(TEST_XID);
Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
}
@Test
public void testSetGlobalLockRequire() throws Exception {
try (ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null))) {
connectionProxy.setGlobalLockRequire(true);
Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
connectionProxy.setGlobalLockRequire(false);
Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
}
@Test
public void testAppendUndoLog() throws Exception {
try (ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null))) {
SQLUndoLog undoLog = new SQLUndoLog();
connectionProxy.appendUndoLog(undoLog);
Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
}
@Test
public void testAppendLockKey() throws Exception {
try (ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null))) {
connectionProxy.appendLockKey("test:1");
connectionProxy.appendLockKey("test:2");
Assertions.assertNotNull(connectionProxy.getContext());
}
@Test
public void testGetTargetConnection() throws Exception {
MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
try (ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
}
@Test
public void testGetDataSourceProxy() throws Exception {
try (ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null))) {
Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
public void testGetContext() throws Exception {
try (ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null))) {
Assertions.assertNotNull(connectionProxy.getContext());
}
@Test
public void testBindXid() throws Exception {
try (ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null))) {
connectionProxy.bind(TEST_XID);
Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
}
@Test
public void testSetGlobalLockRequire() throws Exception {
try (ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null))) {
connectionProxy.setGlobalLockRequire(true);
Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
connectionProxy.setGlobalLockRequire(false);
Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
}
@Test
public void testAppendUndoLog() throws Exception {
try (ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null))) {
SQLUndoLog undoLog = new SQLUndoLog();
connectionProxy.appendUndoLog(undoLog);
Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
}
@Test
public void testAppendLockKey() throws Exception {
try (ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null))) {
connectionProxy.appendLockKey("test:1");
connectionProxy.appendLockKey("test:2");
Assertions.assertNotNull(connectionProxy.getContext());
}
@Test
public void testGetTargetConnection() throws Exception {
MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
try (ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.branchRegister(
Mockito.eq(BranchType.AT),
Mockito.anyString(),
Mockito.isNull(),
Mockito.anyString(),
Mockito.anyString(),
Mockito.anyString()))
.thenReturn(123456L);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.setAutoCommit(false);
connectionProxy.bind(TEST_XID);
SQLUndoLog sqlUndoLog = new SQLUndoLog();
TableRecords beforeImage = new TableRecords();
beforeImage.add(new Row());
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.appendUndoLog(sqlUndoLog);
connectionProxy.appendLockKey(lockKey);
connectionProxy.commit();
Mockito.verify(rm)
.branchRegister(
Mockito.eq(BranchType.AT),
Mockito.anyString(),
Mockito.isNull(),
Mockito.eq(TEST_XID),
Mockito.anyString(),
Mockito.eq(lockKey));
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
public void testAppendLockKey() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, mockConnection);
connectionProxy.appendLockKey("test:1");
connectionProxy.appendLockKey("test:2");
Assertions.assertNotNull(connectionProxy.getContext());
}
@Test
public void testGetTargetConnection() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
}
@Test
public void testGetDataSourceProxy() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, mockConnection);
Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
}
@Test
public void testCheckLockWithBlankLockKeys() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, mockConnection);
connectionProxy.bind(TEST_XID);
connectionProxy.checkLock("");
connectionProxy.checkLock(null);
}
@Test
public void testLockQueryWithBlankLockKeys() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, mockConnection);
connectionProxy.bind(TEST_XID);
boolean result = connectionProxy.lockQuery("");
Assertions.assertFalse(result);
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithGlobalLockRequireTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithoutTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.commit();
+
+ Assertions.assertNull(connectionProxy.getContext().getXid());
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try (ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null))) {
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.branchRegister(
Mockito.eq(BranchType.AT),
Mockito.anyString(),
Mockito.isNull(),
Mockito.anyString(),
Mockito.anyString(),
Mockito.anyString()))
.thenReturn(123456L);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.setAutoCommit(false);
connectionProxy.bind(TEST_XID);
SQLUndoLog sqlUndoLog = new SQLUndoLog();
TableRecords beforeImage = new TableRecords();
beforeImage.add(new Row());
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.appendUndoLog(sqlUndoLog);
connectionProxy.appendLockKey(lockKey);
connectionProxy.commit();
Mockito.verify(rm)
.branchRegister(
Mockito.eq(BranchType.AT),
Mockito.anyString(),
Mockito.isNull(),
Mockito.eq(TEST_XID),
Mockito.anyString(),
Mockito.eq(lockKey));
}
}
@Test
public void commitWithGlobalLockRequireTest() throws Exception {
try (ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null))) {
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.lockQuery(
Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
.thenReturn(true);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.setAutoCommit(false);
connectionProxy.setGlobalLockRequire(true);
connectionProxy.appendLockKey(lockKey);
connectionProxy.commit();
Mockito.verify(rm)
.lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
}
}
@Test
public void commitWithoutTransactionTest() throws Exception {
try (ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null))) {
connectionProxy.setAutoCommit(false);
connectionProxy.commit();
Assertions.assertNull(connectionProxy.getContext().getXid());
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
public void testAppendUndoLog() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, mockConnection);
SQLUndoLog undoLog = new SQLUndoLog();
connectionProxy.appendUndoLog(undoLog);
Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
}
@Test
public void testAppendLockKey() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, mockConnection);
connectionProxy.appendLockKey("test:1");
connectionProxy.appendLockKey("test:2");
Assertions.assertNotNull(connectionProxy.getContext());
}
@Test
public void testGetTargetConnection() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
}
@Test
public void testGetDataSourceProxy() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, mockConnection);
Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
}
@Test
public void testCheckLockWithBlankLockKeys() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, mockConnection);
connectionProxy.bind(TEST_XID);
connectionProxy.checkLock("");
connectionProxy.checkLock(null);
}
@Test
public void testLockQueryWithBlankLockKeys() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy =
new ConnectionProxy(dataSourceProxy, mockConnection);
connectionProxy.bind(TEST_XID);
boolean result = connectionProxy.lockQuery("");
Assertions.assertFalse(result);
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithGlobalLockRequireTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithoutTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.commit();
+
+ Assertions.assertNull(connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void commitWithSQLExceptionTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+ Mockito.doNothing().when(mockConnection).rollback();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ connectionProxy.setAutoCommit(false);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(mockConnection).rollback();
+ }
+
+ @Test
+ public void rollbackTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.rollback();
+
+ Assertions.assertNull(connectionProxy.getContext().getBranchId());
+ }
+
+ @Test
+ public void rollbackWithBranchRegisteredTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.getContext().setBranchId(123456L);
+ connectionProxy.rollback();
+
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(123456L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void registerSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey)))
+ .thenReturn(789L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.branchRegister(
Mockito.eq(BranchType.AT),
Mockito.anyString(),
Mockito.isNull(),
Mockito.anyString(),
Mockito.anyString(),
Mockito.anyString()))
.thenReturn(123456L);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.setAutoCommit(false);
connectionProxy.bind(TEST_XID);
SQLUndoLog sqlUndoLog = new SQLUndoLog();
TableRecords beforeImage = new TableRecords();
beforeImage.add(new Row());
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.appendUndoLog(sqlUndoLog);
connectionProxy.appendLockKey(lockKey);
connectionProxy.commit();
connectionProxy.bind(TEST_XID);
connectionProxy.getContext().setBranchId(123456L);
connectionProxy.rollback();
Mockito.verify(rm)
.branchReport(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_XID),
Mockito.eq(123456L),
Mockito.eq(BranchStatus.PhaseOne_Failed),
Mockito.isNull());
}
}
@Test
public void registerSuccessTest() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.branchRegister(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.isNull(),
Mockito.eq(TEST_XID),
Mockito.anyString(),
Mockito.eq(lockKey)))
.thenReturn(789L);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.setAutoCommit(false);
connectionProxy.bind(TEST_XID);
SQLUndoLog sqlUndoLog = new SQLUndoLog();
TableRecords beforeImage = new TableRecords();
beforeImage.add(new Row());
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.appendUndoLog(sqlUndoLog);
connectionProxy.appendLockKey(lockKey);
connectionProxy.commit();
Mockito.verify(rm)
.branchRegister(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.isNull(),
Mockito.eq(TEST_XID),
Mockito.anyString(),
Mockito.eq(lockKey));
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithGlobalLockRequireTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithoutTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.commit();
+
+ Assertions.assertNull(connectionProxy.getContext().getXid());
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
connectionProxy.setAutoCommit(false);
connectionProxy.commit();
Assertions.assertNull(connectionProxy.getContext().getXid());
} finally {
mockConnection.close();
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithGlobalLockRequireTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithoutTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.commit();
+
+ Assertions.assertNull(connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void commitWithSQLExceptionTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+ Mockito.doNothing().when(mockConnection).rollback();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ connectionProxy.setAutoCommit(false);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(mockConnection).rollback();
+ }
+
+ @Test
+ public void rollbackTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.rollback();
+
+ Assertions.assertNull(connectionProxy.getContext().getBranchId());
+ }
+
+ @Test
+ public void rollbackWithBranchRegisteredTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.getContext().setBranchId(123456L);
+ connectionProxy.rollback();
+
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(123456L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void registerSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey)))
+ .thenReturn(789L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void registerWithNoUndoLogTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.branchRegister(
Mockito.eq(BranchType.AT),
Mockito.anyString(),
Mockito.isNull(),
Mockito.anyString(),
Mockito.anyString(),
Mockito.anyString()))
.thenReturn(123456L);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.setAutoCommit(false);
connectionProxy.bind(TEST_XID);
SQLUndoLog sqlUndoLog = new SQLUndoLog();
TableRecords beforeImage = new TableRecords();
beforeImage.add(new Row());
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.appendUndoLog(sqlUndoLog);
connectionProxy.appendLockKey(lockKey);
connectionProxy.commit();
connectionProxy.bind(TEST_XID);
connectionProxy.getContext().setBranchId(123456L);
connectionProxy.rollback();
Mockito.verify(rm)
.branchReport(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_XID),
Mockito.eq(123456L),
Mockito.eq(BranchStatus.PhaseOne_Failed),
Mockito.isNull());
} finally {
mockConnection.close();
}
}
@Test
public void registerSuccessTest() throws Exception {
MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
try {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.branchRegister(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.isNull(),
Mockito.eq(TEST_XID),
Mockito.anyString(),
Mockito.eq(lockKey)))
.thenReturn(789L);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.setAutoCommit(false);
connectionProxy.bind(TEST_XID);
SQLUndoLog sqlUndoLog = new SQLUndoLog();
TableRecords beforeImage = new TableRecords();
beforeImage.add(new Row());
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.appendUndoLog(sqlUndoLog);
connectionProxy.appendLockKey(lockKey);
connectionProxy.commit();
Mockito.verify(rm)
.branchRegister(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.isNull(),
Mockito.eq(TEST_XID),
Mockito.anyString(),
Mockito.eq(lockKey));
} finally {
mockConnection.close();
}
}
@Test
public void registerWithNoUndoLogTest() throws Exception {
MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
try {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.setAutoCommit(false);
connectionProxy.bind(TEST_XID);
connectionProxy.appendLockKey(lockKey);
connectionProxy.commit();
Mockito.verify(rm, Mockito.never())
.branchRegister(
Mockito.any(),
Mockito.anyString(),
Mockito.any(),
Mockito.anyString(),
Mockito.anyString(),
Mockito.anyString());
} finally {
mockConnection.close();
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithGlobalLockRequireTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithoutTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.commit();
+
+ Assertions.assertNull(connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void commitWithSQLExceptionTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+ Mockito.doNothing().when(mockConnection).rollback();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ connectionProxy.setAutoCommit(false);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(mockConnection).rollback();
+ }
+
+ @Test
+ public void rollbackTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.rollback();
+
+ Assertions.assertNull(connectionProxy.getContext().getBranchId());
+ }
+
+ @Test
+ public void rollbackWithBranchRegisteredTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.getContext().setBranchId(123456L);
+ connectionProxy.rollback();
+
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(123456L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try (ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.branchRegister(
Mockito.eq(BranchType.AT),
Mockito.anyString(),
Mockito.isNull(),
Mockito.anyString(),
Mockito.anyString(),
Mockito.anyString()))
.thenReturn(123456L);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.setAutoCommit(false);
connectionProxy.bind(TEST_XID);
SQLUndoLog sqlUndoLog = new SQLUndoLog();
TableRecords beforeImage = new TableRecords();
beforeImage.add(new Row());
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.appendUndoLog(sqlUndoLog);
connectionProxy.appendLockKey(lockKey);
connectionProxy.commit();
connectionProxy.bind(TEST_XID);
connectionProxy.getContext().setBranchId(123456L);
connectionProxy.rollback();
Mockito.verify(rm)
.branchReport(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_XID),
Mockito.eq(123456L),
Mockito.eq(BranchStatus.PhaseOne_Failed),
Mockito.isNull());
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithGlobalLockRequireTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithoutTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.commit();
+
+ Assertions.assertNull(connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void commitWithSQLExceptionTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+ Mockito.doNothing().when(mockConnection).rollback();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ connectionProxy.setAutoCommit(false);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(mockConnection).rollback();
+ }
+
+ @Test
+ public void rollbackTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.rollback();
+
+ Assertions.assertNull(connectionProxy.getContext().getBranchId());
+ }
+
+ @Test
+ public void rollbackWithBranchRegisteredTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.getContext().setBranchId(123456L);
+ connectionProxy.rollback();
+
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(123456L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void registerSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey)))
+ .thenReturn(789L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void registerWithNoUndoLogTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void registerWithNoLockKeyTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void reportSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(999L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(999L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void reportFailureTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(888L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(rm, Mockito.times(2))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(888L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void reportWithRetryTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(777L);
+ Mockito.doThrow(new TransactionException("Report failed"))
+ .doNothing()
+ .when(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm, Mockito.atLeast(1))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try (ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.branchRegister(
Mockito.eq(BranchType.AT),
Mockito.anyString(),
Mockito.isNull(),
Mockito.anyString(),
Mockito.anyString(),
Mockito.anyString()))
.thenReturn(777L);
Mockito.doThrow(new TransactionException("Report failed"))
.doNothing()
.when(rm)
.branchReport(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_XID),
Mockito.eq(777L),
Mockito.eq(BranchStatus.PhaseOne_Done),
Mockito.isNull());
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.setAutoCommit(false);
connectionProxy.bind(TEST_XID);
SQLUndoLog sqlUndoLog = new SQLUndoLog();
TableRecords beforeImage = new TableRecords();
beforeImage.add(new Row());
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.appendUndoLog(sqlUndoLog);
connectionProxy.appendLockKey(lockKey);
connectionProxy.commit();
if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
Mockito.verify(rm, Mockito.atLeast(1))
.branchReport(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_XID),
Mockito.eq(777L),
Mockito.eq(BranchStatus.PhaseOne_Done),
Mockito.isNull());
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
Assertions.assertNotNull(connectionProxy.getContext());
}
}
@Test
public void testBindXid() {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
connectionProxy.bind(TEST_XID);
Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
}
}
@Test
public void testSetGlobalLockRequire() {
ConnectionProxy connectionProxy =
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
connectionProxy.setGlobalLockRequire(true);
Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
connectionProxy.setGlobalLockRequire(false);
Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithGlobalLockRequireTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithoutTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.commit();
+
+ Assertions.assertNull(connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void commitWithSQLExceptionTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+ Mockito.doNothing().when(mockConnection).rollback();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ connectionProxy.setAutoCommit(false);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(mockConnection).rollback();
+ }
+
+ @Test
+ public void rollbackTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.rollback();
+
+ Assertions.assertNull(connectionProxy.getContext().getBranchId());
+ }
+
+ @Test
+ public void rollbackWithBranchRegisteredTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.getContext().setBranchId(123456L);
+ connectionProxy.rollback();
+
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(123456L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void registerSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey)))
+ .thenReturn(789L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void registerWithNoUndoLogTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void registerWithNoLockKeyTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void reportSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(999L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(999L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void reportFailureTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(888L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(rm, Mockito.times(2))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(888L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void reportWithRetryTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(777L);
+ Mockito.doThrow(new TransactionException("Report failed"))
+ .doNothing()
+ .when(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm, Mockito.atLeast(1))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void setAutoCommitToTrueInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(555L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.setAutoCommit(true);
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ Assertions.assertTrue(mockConnection.getAutoCommit());
+ }
+
+ @Test
+ public void setAutoCommitToTrueWithGlobalLockTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.setAutoCommit(true);
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ Assertions.assertTrue(mockConnection.getAutoCommit());
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try {
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.lockQuery(
Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
.thenReturn(true);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.setAutoCommit(false);
connectionProxy.setGlobalLockRequire(true);
connectionProxy.appendLockKey(lockKey);
connectionProxy.setAutoCommit(true);
Mockito.verify(rm)
.lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
Assertions.assertTrue(mockConnection.getAutoCommit());
} finally {
mockConnection.close();
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithGlobalLockRequireTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithoutTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.commit();
+
+ Assertions.assertNull(connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void commitWithSQLExceptionTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+ Mockito.doNothing().when(mockConnection).rollback();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ connectionProxy.setAutoCommit(false);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(mockConnection).rollback();
+ }
+
+ @Test
+ public void rollbackTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.rollback();
+
+ Assertions.assertNull(connectionProxy.getContext().getBranchId());
+ }
+
+ @Test
+ public void rollbackWithBranchRegisteredTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.getContext().setBranchId(123456L);
+ connectionProxy.rollback();
+
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(123456L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void registerSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey)))
+ .thenReturn(789L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void registerWithNoUndoLogTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void registerWithNoLockKeyTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.branchRegister(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.isNull(),
Mockito.eq(TEST_XID),
Mockito.anyString(),
Mockito.eq(lockKey)))
.thenReturn(789L);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.setAutoCommit(false);
connectionProxy.bind(TEST_XID);
SQLUndoLog sqlUndoLog = new SQLUndoLog();
TableRecords beforeImage = new TableRecords();
beforeImage.add(new Row());
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.appendUndoLog(sqlUndoLog);
connectionProxy.appendLockKey(lockKey);
connectionProxy.commit();
Mockito.verify(rm)
.branchRegister(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.isNull(),
Mockito.eq(TEST_XID),
Mockito.anyString(),
Mockito.eq(lockKey));
}
}
@Test
public void registerWithNoUndoLogTest() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.setAutoCommit(false);
connectionProxy.bind(TEST_XID);
connectionProxy.appendLockKey(lockKey);
connectionProxy.commit();
Mockito.verify(rm, Mockito.never())
.branchRegister(
Mockito.any(),
Mockito.anyString(),
Mockito.any(),
Mockito.anyString(),
Mockito.anyString(),
Mockito.anyString());
}
}
@Test
public void registerWithNoLockKeyTest() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.setAutoCommit(false);
connectionProxy.bind(TEST_XID);
connectionProxy.commit();
Mockito.verify(rm, Mockito.never())
.branchRegister(
Mockito.any(),
Mockito.anyString(),
Mockito.any(),
Mockito.anyString(),
Mockito.anyString(),
Mockito.anyString());
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithGlobalLockRequireTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithoutTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.commit();
+
+ Assertions.assertNull(connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void commitWithSQLExceptionTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+ Mockito.doNothing().when(mockConnection).rollback();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ connectionProxy.setAutoCommit(false);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(mockConnection).rollback();
+ }
+
+ @Test
+ public void rollbackTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.rollback();
+
+ Assertions.assertNull(connectionProxy.getContext().getBranchId());
+ }
+
+ @Test
+ public void rollbackWithBranchRegisteredTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.getContext().setBranchId(123456L);
+ connectionProxy.rollback();
+
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(123456L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void registerSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey)))
+ .thenReturn(789L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void registerWithNoUndoLogTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void registerWithNoLockKeyTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void reportSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(999L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(999L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void reportFailureTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(888L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(rm, Mockito.times(2))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(888L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void reportWithRetryTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(777L);
+ Mockito.doThrow(new TransactionException("Report failed"))
+ .doNothing()
+ .when(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm, Mockito.atLeast(1))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void setAutoCommitToTrueInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(555L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.setAutoCommit(true);
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ Assertions.assertTrue(mockConnection.getAutoCommit());
+ }
+
+ @Test
+ public void setAutoCommitToTrueWithGlobalLockTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.setAutoCommit(true);
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ Assertions.assertTrue(mockConnection.getAutoCommit());
+ }
+
+ @Test
+ public void checkLockWithRealLockKeysTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.checkLock(lockKey);
+
+ Mockito.verify(rm)
+ .lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey));
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.lockQuery(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.eq(TEST_XID),
Mockito.eq(lockKey)))
.thenReturn(true);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.bind(TEST_XID);
connectionProxy.checkLock(lockKey);
Mockito.verify(rm)
.lockQuery(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.eq(TEST_XID),
Mockito.eq(lockKey));
} finally {
mockConnection.close();
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithGlobalLockRequireTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithoutTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.commit();
+
+ Assertions.assertNull(connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void commitWithSQLExceptionTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+ Mockito.doNothing().when(mockConnection).rollback();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ connectionProxy.setAutoCommit(false);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(mockConnection).rollback();
+ }
+
+ @Test
+ public void rollbackTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.rollback();
+
+ Assertions.assertNull(connectionProxy.getContext().getBranchId());
+ }
+
+ @Test
+ public void rollbackWithBranchRegisteredTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.getContext().setBranchId(123456L);
+ connectionProxy.rollback();
+
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(123456L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void registerSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey)))
+ .thenReturn(789L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void registerWithNoUndoLogTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void registerWithNoLockKeyTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void reportSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(999L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(999L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void reportFailureTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(888L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(rm, Mockito.times(2))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(888L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void reportWithRetryTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(777L);
+ Mockito.doThrow(new TransactionException("Report failed"))
+ .doNothing()
+ .when(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm, Mockito.atLeast(1))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void setAutoCommitToTrueInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(555L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.setAutoCommit(true);
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ Assertions.assertTrue(mockConnection.getAutoCommit());
+ }
+
+ @Test
+ public void setAutoCommitToTrueWithGlobalLockTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.setAutoCommit(true);
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ Assertions.assertTrue(mockConnection.getAutoCommit());
+ }
+
+ @Test
+ public void checkLockWithRealLockKeysTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.checkLock(lockKey);
+
+ Mockito.verify(rm)
+ .lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void checkLockWithConflictTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(false);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ Assertions.assertThrows(LockConflictException.class, () -> connectionProxy.checkLock(lockKey));
+ }
+
+ @Test
+ public void lockQueryReturnsTrueTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ boolean result = connectionProxy.lockQuery(lockKey);
+
+ Assertions.assertTrue(result);
+ }
+
+ @Test
+ public void lockQueryReturnsFalseTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(false);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ boolean result = connectionProxy.lockQuery(lockKey);
+
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void setSavepointTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ Savepoint savepoint = connectionProxy.setSavepoint();
+
+ Assertions.assertNotNull(savepoint);
+ }
+
+ @Test
+ public void setSavepointWithNameTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ String savepointName = "sp1";
+ Savepoint savepoint = connectionProxy.setSavepoint(savepointName);
+
+ Assertions.assertNotNull(savepoint);
+ }
+
+ @Test
+ public void rollbackToSavepointTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ Savepoint savepoint = connectionProxy.setSavepoint();
+ Assertions.assertNotNull(savepoint);
+
+ connectionProxy.rollback(savepoint);
+
+ Assertions.assertNotNull(connectionProxy.getContext());
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.lockQuery(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.eq(TEST_XID),
Mockito.eq(lockKey)))
.thenReturn(true);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.bind(TEST_XID);
boolean result = connectionProxy.lockQuery(lockKey);
Assertions.assertTrue(result);
}
}
@Test
public void lockQueryReturnsFalseTest() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.lockQuery(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.eq(TEST_XID),
Mockito.eq(lockKey)))
.thenReturn(false);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.bind(TEST_XID);
boolean result = connectionProxy.lockQuery(lockKey);
Assertions.assertFalse(result);
}
}
@Test
public void setSavepointTest() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
Savepoint savepoint = connectionProxy.setSavepoint();
Assertions.assertNotNull(savepoint);
}
}
@Test
public void setSavepointWithNameTest() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
String savepointName = "sp1";
Savepoint savepoint = connectionProxy.setSavepoint(savepointName);
Assertions.assertNotNull(savepoint);
}
}
@Test
public void rollbackToSavepointTest() throws Exception {
try (MockConnection mockConnection = new MockConnection(new MockDriver(), "", null)) {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
Savepoint savepoint = connectionProxy.setSavepoint();
Assertions.assertNotNull(savepoint);
connectionProxy.rollback(savepoint);
Assertions.assertNotNull(connectionProxy.getContext());
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithGlobalLockRequireTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithoutTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.commit();
+
+ Assertions.assertNull(connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void commitWithSQLExceptionTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+ Mockito.doNothing().when(mockConnection).rollback();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ connectionProxy.setAutoCommit(false);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(mockConnection).rollback();
+ }
+
+ @Test
+ public void rollbackTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.rollback();
+
+ Assertions.assertNull(connectionProxy.getContext().getBranchId());
+ }
+
+ @Test
+ public void rollbackWithBranchRegisteredTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.getContext().setBranchId(123456L);
+ connectionProxy.rollback();
+
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(123456L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void registerSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey)))
+ .thenReturn(789L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void registerWithNoUndoLogTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void registerWithNoLockKeyTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void reportSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(999L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(999L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void reportFailureTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(888L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(rm, Mockito.times(2))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(888L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void reportWithRetryTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(777L);
+ Mockito.doThrow(new TransactionException("Report failed"))
+ .doNothing()
+ .when(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm, Mockito.atLeast(1))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void setAutoCommitToTrueInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(555L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.setAutoCommit(true);
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ Assertions.assertTrue(mockConnection.getAutoCommit());
+ }
+
+ @Test
+ public void setAutoCommitToTrueWithGlobalLockTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.setAutoCommit(true);
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ Assertions.assertTrue(mockConnection.getAutoCommit());
+ }
+
+ @Test
+ public void checkLockWithRealLockKeysTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.checkLock(lockKey);
+
+ Mockito.verify(rm)
+ .lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void checkLockWithConflictTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(false);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ Assertions.assertThrows(LockConflictException.class, () -> connectionProxy.checkLock(lockKey));
+ }
+
+ @Test
+ public void lockQueryReturnsTrueTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ boolean result = connectionProxy.lockQuery(lockKey);
+
+ Assertions.assertTrue(result);
+ }
+
+ @Test
+ public void lockQueryReturnsFalseTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(false);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ boolean result = connectionProxy.lockQuery(lockKey);
+
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void setSavepointTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ Savepoint savepoint = connectionProxy.setSavepoint();
+
+ Assertions.assertNotNull(savepoint);
+ }
+
+ @Test
+ public void setSavepointWithNameTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ String savepointName = "sp1";
+ Savepoint savepoint = connectionProxy.setSavepoint(savepointName);
+
+ Assertions.assertNotNull(savepoint);
+ }
+
+ @Test
+ public void rollbackToSavepointTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ Savepoint savepoint = connectionProxy.setSavepoint();
+ Assertions.assertNotNull(savepoint);
+
+ connectionProxy.rollback(savepoint);
+
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void releaseSavepointTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ Savepoint savepoint = connectionProxy.setSavepoint();
+ Assertions.assertNotNull(savepoint);
+
+ connectionProxy.releaseSavepoint(savepoint);
+
+ Assertions.assertNotNull(connectionProxy.getContext());
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.lockQuery(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.eq(TEST_XID),
Mockito.eq(lockKey)))
.thenReturn(false);
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.bind(TEST_XID);
boolean result = connectionProxy.lockQuery(lockKey);
Assertions.assertFalse(result);
} finally {
mockConnection.close();
}
}
@Test
public void setSavepointTest() throws Exception {
MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
try {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
Savepoint savepoint = connectionProxy.setSavepoint();
Assertions.assertNotNull(savepoint);
} finally {
mockConnection.close();
}
}
@Test
public void setSavepointWithNameTest() throws Exception {
MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
try {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
String savepointName = "sp1";
Savepoint savepoint = connectionProxy.setSavepoint(savepointName);
Assertions.assertNotNull(savepoint);
} finally {
mockConnection.close();
}
}
@Test
public void rollbackToSavepointTest() throws Exception {
MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
try {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
Savepoint savepoint = connectionProxy.setSavepoint();
Assertions.assertNotNull(savepoint);
connectionProxy.rollback(savepoint);
Assertions.assertNotNull(connectionProxy.getContext());
} finally {
mockConnection.close();
}
}
@Test
public void releaseSavepointTest() throws Exception {
MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
try {
ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
Savepoint savepoint = connectionProxy.setSavepoint();
Assertions.assertNotNull(savepoint);
connectionProxy.releaseSavepoint(savepoint);
Assertions.assertNotNull(connectionProxy.getContext());
} finally {
mockConnection.close();
}
```
##########
rm-datasource/src/test/java/org/apache/seata/rm/datasource/ConnectionProxyTest.java:
##########
@@ -130,6 +136,662 @@ public void testLockRetryPolicyNotRollbackOnConflict() throws Exception {
sqlUndoLog.setBeforeImage(beforeImage);
connectionProxy.getContext().appendUndoItem(sqlUndoLog);
Assertions.assertThrows(LockWaitTimeoutException.class, connectionProxy::commit);
- branchRollbackFlagField.set(null, oldBranchRollbackFlag);
+ }
+
+ @Test
+ public void testGetContext() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testBindXid() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ Assertions.assertEquals(TEST_XID, connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void testSetGlobalLockRequire() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.setGlobalLockRequire(true);
+ Assertions.assertTrue(connectionProxy.isGlobalLockRequire());
+ connectionProxy.setGlobalLockRequire(false);
+ Assertions.assertFalse(connectionProxy.isGlobalLockRequire());
+ }
+
+ @Test
+ public void testAppendUndoLog() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ SQLUndoLog undoLog = new SQLUndoLog();
+ connectionProxy.appendUndoLog(undoLog);
+ Assertions.assertEquals(1, connectionProxy.getContext().getUndoItems().size());
+ }
+
+ @Test
+ public void testAppendLockKey() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.appendLockKey("test:1");
+ connectionProxy.appendLockKey("test:2");
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void testGetTargetConnection() {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ Assertions.assertEquals(mockConnection, connectionProxy.getTargetConnection());
+ }
+
+ @Test
+ public void testGetDataSourceProxy() {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ Assertions.assertEquals(dataSourceProxy, connectionProxy.getDataSourceProxy());
+ }
+
+ @Test
+ public void testCheckLockWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.checkLock("");
+ connectionProxy.checkLock(null);
+ }
+
+ @Test
+ public void testLockQueryWithBlankLockKeys() throws Exception {
+ ConnectionProxy connectionProxy =
+ new ConnectionProxy(dataSourceProxy, new MockConnection(new MockDriver(), "", null));
+ connectionProxy.bind(TEST_XID);
+ boolean result = connectionProxy.lockQuery("");
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void commitInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithGlobalLockRequireTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void commitWithoutTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.commit();
+
+ Assertions.assertNull(connectionProxy.getContext().getXid());
+ }
+
+ @Test
+ public void commitWithSQLExceptionTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+ Mockito.doNothing().when(mockConnection).rollback();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+ connectionProxy.setAutoCommit(false);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(mockConnection).rollback();
+ }
+
+ @Test
+ public void rollbackTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ connectionProxy.setAutoCommit(false);
+
+ connectionProxy.rollback();
+
+ Assertions.assertNull(connectionProxy.getContext().getBranchId());
+ }
+
+ @Test
+ public void rollbackWithBranchRegisteredTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(123456L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.getContext().setBranchId(123456L);
+ connectionProxy.rollback();
+
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(123456L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void registerSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey)))
+ .thenReturn(789L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void registerWithNoUndoLogTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void registerWithNoLockKeyTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.commit();
+
+ Mockito.verify(rm, Mockito.never())
+ .branchRegister(
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.any(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ }
+
+ @Test
+ public void reportSuccessTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(999L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(999L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void reportFailureTest() throws Exception {
+ MockConnection mockConnection = Mockito.mock(MockConnection.class);
+ Mockito.when(mockConnection.getAutoCommit()).thenReturn(false);
+ Mockito.doThrow(new SQLException("Commit failed")).when(mockConnection).commit();
+
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(888L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ Assertions.assertThrows(SQLException.class, connectionProxy::commit);
+
+ Mockito.verify(rm, Mockito.times(2))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(888L),
+ Mockito.eq(BranchStatus.PhaseOne_Failed),
+ Mockito.isNull());
+ }
+
+ @Test
+ public void reportWithRetryTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(777L);
+ Mockito.doThrow(new TransactionException("Report failed"))
+ .doNothing()
+ .when(rm)
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.commit();
+
+ if (ConnectionProxy.IS_REPORT_SUCCESS_ENABLE) {
+ Mockito.verify(rm, Mockito.atLeast(1))
+ .branchReport(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(777L),
+ Mockito.eq(BranchStatus.PhaseOne_Done),
+ Mockito.isNull());
+ }
+ }
+
+ @Test
+ public void setAutoCommitToTrueInGlobalTransactionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.anyString()))
+ .thenReturn(555L);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.bind(TEST_XID);
+ SQLUndoLog sqlUndoLog = new SQLUndoLog();
+ TableRecords beforeImage = new TableRecords();
+ beforeImage.add(new Row());
+ sqlUndoLog.setBeforeImage(beforeImage);
+ connectionProxy.appendUndoLog(sqlUndoLog);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.setAutoCommit(true);
+
+ Mockito.verify(rm)
+ .branchRegister(
+ Mockito.eq(BranchType.AT),
+ Mockito.anyString(),
+ Mockito.isNull(),
+ Mockito.eq(TEST_XID),
+ Mockito.anyString(),
+ Mockito.eq(lockKey));
+ Assertions.assertTrue(mockConnection.getAutoCommit());
+ }
+
+ @Test
+ public void setAutoCommitToTrueWithGlobalLockTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.anyString()))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.setAutoCommit(false);
+ connectionProxy.setGlobalLockRequire(true);
+ connectionProxy.appendLockKey(lockKey);
+
+ connectionProxy.setAutoCommit(true);
+
+ Mockito.verify(rm)
+ .lockQuery(Mockito.eq(BranchType.AT), Mockito.anyString(), Mockito.isNull(), Mockito.eq(lockKey));
+ Assertions.assertTrue(mockConnection.getAutoCommit());
+ }
+
+ @Test
+ public void checkLockWithRealLockKeysTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ connectionProxy.checkLock(lockKey);
+
+ Mockito.verify(rm)
+ .lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey));
+ }
+
+ @Test
+ public void checkLockWithConflictTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(false);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ Assertions.assertThrows(LockConflictException.class, () -> connectionProxy.checkLock(lockKey));
+ }
+
+ @Test
+ public void lockQueryReturnsTrueTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(true);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ boolean result = connectionProxy.lockQuery(lockKey);
+
+ Assertions.assertTrue(result);
+ }
+
+ @Test
+ public void lockQueryReturnsFalseTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenReturn(false);
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ boolean result = connectionProxy.lockQuery(lockKey);
+
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void setSavepointTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ Savepoint savepoint = connectionProxy.setSavepoint();
+
+ Assertions.assertNotNull(savepoint);
+ }
+
+ @Test
+ public void setSavepointWithNameTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ String savepointName = "sp1";
+ Savepoint savepoint = connectionProxy.setSavepoint(savepointName);
+
+ Assertions.assertNotNull(savepoint);
+ }
+
+ @Test
+ public void rollbackToSavepointTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ Savepoint savepoint = connectionProxy.setSavepoint();
+ Assertions.assertNotNull(savepoint);
+
+ connectionProxy.rollback(savepoint);
+
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void releaseSavepointTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ Savepoint savepoint = connectionProxy.setSavepoint();
+ Assertions.assertNotNull(savepoint);
+
+ connectionProxy.releaseSavepoint(savepoint);
+
+ Assertions.assertNotNull(connectionProxy.getContext());
+ }
+
+ @Test
+ public void recognizeLockKeyConflictExceptionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenThrow(new TransactionException(TransactionExceptionCode.LockKeyConflict, "lock conflict"));
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ LockConflictException exception =
+ Assertions.assertThrows(LockConflictException.class, () -> connectionProxy.checkLock(lockKey));
+ Assertions.assertEquals(TransactionExceptionCode.LockKeyConflict, exception.getCode());
+ }
+
+ @Test
+ public void recognizeLockKeyConflictFailFastExceptionTest() throws Exception {
+ MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
+ ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection);
+
+ DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
+ Mockito.when(rm.lockQuery(
+ Mockito.eq(BranchType.AT),
+ Mockito.eq(TEST_RESOURCE_ID),
+ Mockito.eq(TEST_XID),
+ Mockito.eq(lockKey)))
+ .thenThrow(new TransactionException(
+ TransactionExceptionCode.LockKeyConflictFailFast, "lock conflict fail fast"));
+ DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
+
+ connectionProxy.bind(TEST_XID);
+
+ LockConflictException exception =
+ Assertions.assertThrows(LockConflictException.class, () -> connectionProxy.checkLock(lockKey));
+ Assertions.assertEquals(TransactionExceptionCode.LockKeyConflictFailFast, exception.getCode());
Review Comment:
This MockConnection is not always closed on method exit.
```suggestion
try (ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
Savepoint savepoint = connectionProxy.setSavepoint();
Assertions.assertNotNull(savepoint);
}
}
@Test
public void setSavepointWithNameTest() throws Exception {
MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
try (ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
String savepointName = "sp1";
Savepoint savepoint = connectionProxy.setSavepoint(savepointName);
Assertions.assertNotNull(savepoint);
}
}
@Test
public void rollbackToSavepointTest() throws Exception {
MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
try (ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
Savepoint savepoint = connectionProxy.setSavepoint();
Assertions.assertNotNull(savepoint);
connectionProxy.rollback(savepoint);
Assertions.assertNotNull(connectionProxy.getContext());
}
}
@Test
public void releaseSavepointTest() throws Exception {
MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
try (ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
Savepoint savepoint = connectionProxy.setSavepoint();
Assertions.assertNotNull(savepoint);
connectionProxy.releaseSavepoint(savepoint);
Assertions.assertNotNull(connectionProxy.getContext());
}
}
@Test
public void recognizeLockKeyConflictExceptionTest() throws Exception {
MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
try (ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.lockQuery(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.eq(TEST_XID),
Mockito.eq(lockKey)))
.thenThrow(new TransactionException(TransactionExceptionCode.LockKeyConflict, "lock conflict"));
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.bind(TEST_XID);
LockConflictException exception =
Assertions.assertThrows(LockConflictException.class, () -> connectionProxy.checkLock(lockKey));
Assertions.assertEquals(TransactionExceptionCode.LockKeyConflict, exception.getCode());
}
}
@Test
public void recognizeLockKeyConflictFailFastExceptionTest() throws Exception {
MockConnection mockConnection = new MockConnection(new MockDriver(), "", null);
try (ConnectionProxy connectionProxy = new ConnectionProxy(dataSourceProxy, mockConnection)) {
DefaultResourceManager rm = Mockito.mock(DefaultResourceManager.class);
Mockito.when(rm.lockQuery(
Mockito.eq(BranchType.AT),
Mockito.eq(TEST_RESOURCE_ID),
Mockito.eq(TEST_XID),
Mockito.eq(lockKey)))
.thenThrow(new TransactionException(
TransactionExceptionCode.LockKeyConflictFailFast, "lock conflict fail fast"));
DefaultResourceManager.mockResourceManager(BranchType.AT, rm);
connectionProxy.bind(TEST_XID);
LockConflictException exception =
Assertions.assertThrows(LockConflictException.class, () -> connectionProxy.checkLock(lockKey));
Assertions.assertEquals(TransactionExceptionCode.LockKeyConflictFailFast, exception.getCode());
}
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@seata.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: notifications-unsubscribe@seata.apache.org
For additional commands, e-mail: notifications-help@seata.apache.org
Re: [PR] test: improve test coverage for rm-datasource [incubator-seata]
Posted by "codecov[bot] (via GitHub)" <gi...@apache.org>.
codecov[bot] commented on PR #7788:
URL: https://github.com/apache/incubator-seata/pull/7788#issuecomment-3541377794
## [Codecov](https://app.codecov.io/gh/apache/incubator-seata/pull/7788?dropdown=coverage&src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache) Report
:x: Patch coverage is `87.50000%` with `1 line` in your changes missing coverage. Please review.
:white_check_mark: Project coverage is 69.71%. Comparing base ([`8536df5`](https://app.codecov.io/gh/apache/incubator-seata/commit/8536df526cd8368bc30befe9d16fd0ba277b06de?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache)) to head ([`9f4a410`](https://app.codecov.io/gh/apache/incubator-seata/commit/9f4a410ad7275e4397585caa526e5d692614b474?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache)).
| [Files with missing lines](https://app.codecov.io/gh/apache/incubator-seata/pull/7788?dropdown=coverage&src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache) | Patch % | Lines |
|---|---|---|
| [...ource/sql/struct/cache/AbstractTableMetaCache.java](https://app.codecov.io/gh/apache/incubator-seata/pull/7788?src=pr&el=tree&filepath=rm-datasource%2Fsrc%2Fmain%2Fjava%2Forg%2Fapache%2Fseata%2Frm%2Fdatasource%2Fsql%2Fstruct%2Fcache%2FAbstractTableMetaCache.java&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache#diff-cm0tZGF0YXNvdXJjZS9zcmMvbWFpbi9qYXZhL29yZy9hcGFjaGUvc2VhdGEvcm0vZGF0YXNvdXJjZS9zcWwvc3RydWN0L2NhY2hlL0Fic3RyYWN0VGFibGVNZXRhQ2FjaGUuamF2YQ==) | 83.33% | [0 Missing and 1 partial :warning: ](https://app.codecov.io/gh/apache/incubator-seata/pull/7788?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache) |
<details><summary>Additional details and impacted files</summary>
```diff
@@ Coverage Diff @@
## 2.x #7788 +/- ##
============================================
+ Coverage 69.24% 69.71% +0.47%
Complexity 994 994
============================================
Files 1322 1322
Lines 50175 50177 +2
Branches 5932 5932
============================================
+ Hits 34745 34983 +238
+ Misses 12519 12262 -257
- Partials 2911 2932 +21
```
| [Files with missing lines](https://app.codecov.io/gh/apache/incubator-seata/pull/7788?dropdown=coverage&src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache) | Coverage Δ | |
|---|---|---|
| [...ec/mysql/MySQLInsertOnDuplicateUpdateExecutor.java](https://app.codecov.io/gh/apache/incubator-seata/pull/7788?src=pr&el=tree&filepath=rm-datasource%2Fsrc%2Fmain%2Fjava%2Forg%2Fapache%2Fseata%2Frm%2Fdatasource%2Fexec%2Fmysql%2FMySQLInsertOnDuplicateUpdateExecutor.java&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache#diff-cm0tZGF0YXNvdXJjZS9zcmMvbWFpbi9qYXZhL29yZy9hcGFjaGUvc2VhdGEvcm0vZGF0YXNvdXJjZS9leGVjL215c3FsL015U1FMSW5zZXJ0T25EdXBsaWNhdGVVcGRhdGVFeGVjdXRvci5qYXZh) | `42.52% <100.00%> (+10.12%)` | :arrow_up: |
| [...ource/sql/struct/cache/AbstractTableMetaCache.java](https://app.codecov.io/gh/apache/incubator-seata/pull/7788?src=pr&el=tree&filepath=rm-datasource%2Fsrc%2Fmain%2Fjava%2Forg%2Fapache%2Fseata%2Frm%2Fdatasource%2Fsql%2Fstruct%2Fcache%2FAbstractTableMetaCache.java&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache#diff-cm0tZGF0YXNvdXJjZS9zcmMvbWFpbi9qYXZhL29yZy9hcGFjaGUvc2VhdGEvcm0vZGF0YXNvdXJjZS9zcWwvc3RydWN0L2NhY2hlL0Fic3RyYWN0VGFibGVNZXRhQ2FjaGUuamF2YQ==) | `85.36% <83.33%> (+0.36%)` | :arrow_up: |
... and [18 files with indirect coverage changes](https://app.codecov.io/gh/apache/incubator-seata/pull/7788/indirect-changes?src=pr&el=tree-more&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache)
[](https://app.codecov.io/gh/apache/incubator-seata/pull/7788?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache)
</details>
<details><summary> :rocket: New features to boost your workflow: </summary>
- :snowflake: [Test Analytics](https://docs.codecov.com/docs/test-analytics): Detect flaky tests, report on failures, and find test suite problems.
- :package: [JS Bundle Analysis](https://docs.codecov.com/docs/javascript-bundle-analysis): Save yourself from yourself by tracking and limiting bundle sizes in JS merges.
</details>
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@seata.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: notifications-unsubscribe@seata.apache.org
For additional commands, e-mail: notifications-help@seata.apache.org
Re: [PR] test: improve test coverage for rm-datasource [incubator-seata]
Posted by "slievrly (via GitHub)" <gi...@apache.org>.
slievrly merged PR #7788:
URL: https://github.com/apache/incubator-seata/pull/7788
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@seata.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: notifications-unsubscribe@seata.apache.org
For additional commands, e-mail: notifications-help@seata.apache.org