You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cloudstack.apache.org by wi...@apache.org on 2013/11/20 15:51:03 UTC
[33/50] [abbrv] git commit: updated refs/heads/disk-cache to 6f3e4d3
Tests for DBUtil
This patch adds test for the lock management:
- getGlobalLock
- releaseGlobalLock
Signed-off-by: Laszlo Hornyak <la...@gmail.com>
Project: http://git-wip-us.apache.org/repos/asf/cloudstack/repo
Commit: http://git-wip-us.apache.org/repos/asf/cloudstack/commit/065e5afa
Tree: http://git-wip-us.apache.org/repos/asf/cloudstack/tree/065e5afa
Diff: http://git-wip-us.apache.org/repos/asf/cloudstack/diff/065e5afa
Branch: refs/heads/disk-cache
Commit: 065e5afa08a34d414cdb8ced092c0dc8756c8463
Parents: 438cf4e
Author: Laszlo Hornyak <la...@gmail.com>
Authored: Sat Nov 16 14:25:29 2013 +0100
Committer: Laszlo Hornyak <la...@gmail.com>
Committed: Sat Nov 16 15:44:31 2013 +0100
----------------------------------------------------------------------
framework/db/pom.xml | 4 +
framework/db/src/com/cloud/utils/db/DbUtil.java | 31 ++-
.../db/test/com/cloud/utils/DbUtilTest.java | 190 +++++++++++++++++++
3 files changed, 206 insertions(+), 19 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/065e5afa/framework/db/pom.xml
----------------------------------------------------------------------
diff --git a/framework/db/pom.xml b/framework/db/pom.xml
index e28628e..b24b742 100644
--- a/framework/db/pom.xml
+++ b/framework/db/pom.xml
@@ -36,6 +36,10 @@
<artifactId>commons-dbcp</artifactId>
</dependency>
<dependency>
+ <groupId>commons-io</groupId>
+ <artifactId>commons-io</artifactId>
+ </dependency>
+ <dependency>
<groupId>commons-pool</groupId>
<artifactId>commons-pool</artifactId>
</dependency>
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/065e5afa/framework/db/src/com/cloud/utils/db/DbUtil.java
----------------------------------------------------------------------
diff --git a/framework/db/src/com/cloud/utils/db/DbUtil.java b/framework/db/src/com/cloud/utils/db/DbUtil.java
index 2570093..2a613d2 100755
--- a/framework/db/src/com/cloud/utils/db/DbUtil.java
+++ b/framework/db/src/com/cloud/utils/db/DbUtil.java
@@ -208,13 +208,14 @@ public class DbUtil {
}
PreparedStatement pstmt = null;
+ ResultSet rs = null;
try {
pstmt = conn.prepareStatement("SELECT COALESCE(GET_LOCK(?, ?),0)");
pstmt.setString(1, name);
pstmt.setInt(2, timeoutSeconds);
- ResultSet rs = pstmt.executeQuery();
+ rs = pstmt.executeQuery();
if (rs != null && rs.first()) {
if(rs.getInt(1) > 0) {
return true;
@@ -228,13 +229,8 @@ public class DbUtil {
} catch (Throwable e) {
s_logger.error("GET_LOCK() throws exception ", e);
} finally {
- if (pstmt != null) {
- try {
- pstmt.close();
- } catch (Throwable e) {
- s_logger.error("What the heck? ", e);
- }
- }
+ closeStatement(pstmt);
+ closeResultSet(rs);
}
removeConnectionForGlobalLocks(name);
@@ -259,10 +255,11 @@ public class DbUtil {
}
PreparedStatement pstmt = null;
+ ResultSet rs = null;
try {
pstmt = conn.prepareStatement("SELECT COALESCE(RELEASE_LOCK(?), 0)");
pstmt.setString(1, name);
- ResultSet rs = pstmt.executeQuery();
+ rs = pstmt.executeQuery();
if(rs != null && rs.first())
return rs.getInt(1) > 0;
s_logger.error("RELEASE_LOCK() returns unexpected result : " + rs.getInt(1));
@@ -271,13 +268,9 @@ public class DbUtil {
} catch (Throwable e) {
s_logger.error("RELEASE_LOCK() throws exception ", e);
} finally {
- try {
- if (pstmt != null) {
- pstmt.close();
- }
- conn.close();
- } catch(SQLException e) {
- }
+ closeResultSet(rs);
+ closeStatement(pstmt);
+ closeConnection(conn);
}
return false;
}
@@ -305,7 +298,7 @@ public class DbUtil {
resultSet.close();
}
- } catch (Exception e) {
+ } catch (SQLException e) {
s_logger.warn("Ignored exception while closing result set.",e);
}
@@ -319,7 +312,7 @@ public class DbUtil {
statement.close();
}
- } catch (Exception e) {
+ } catch (SQLException e) {
s_logger.warn("Ignored exception while closing statement.",e);
}
@@ -333,7 +326,7 @@ public class DbUtil {
connection.close();
}
- } catch (Exception e) {
+ } catch (SQLException e) {
s_logger.warn("Ignored exception while close connection.",e);
}
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/065e5afa/framework/db/test/com/cloud/utils/DbUtilTest.java
----------------------------------------------------------------------
diff --git a/framework/db/test/com/cloud/utils/DbUtilTest.java b/framework/db/test/com/cloud/utils/DbUtilTest.java
index e9a7287..4839c23 100644
--- a/framework/db/test/com/cloud/utils/DbUtilTest.java
+++ b/framework/db/test/com/cloud/utils/DbUtilTest.java
@@ -16,16 +16,58 @@
// under the License.
package com.cloud.utils;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.HashMap;
+import java.util.Map;
+
import javax.persistence.Column;
+import javax.persistence.Table;
+import javax.sql.DataSource;
+import org.junit.After;
import org.junit.Assert;
+import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
import com.cloud.utils.db.DbUtil;
+import com.cloud.utils.db.TransactionLegacy;
+@RunWith(MockitoJUnitRunner.class)
public class DbUtilTest {
+ @Mock
+ Connection connection;
+
+ @Mock
+ PreparedStatement preparedStatement;
+
+ @Mock
+ Statement statement;
+
+ @Mock
+ ResultSet resultSet;
+
+ @Mock
+ DataSource dataSource;
+
+ DataSource backup;
+
+ Map<String, Connection> connectionMapBackup = null;
+
+ Map<String, Connection> connectionMap = null;
+
+ @Table(name = "test_table")
static class Testbean {
String noAnnotation;
@Column()
@@ -78,4 +120,152 @@ public class DbUtilTest {
.getDeclaredField("instanceField")));
}
+ class Bar {
+
+ }
+
+ @Test
+ public void getTableName() {
+ Assert.assertEquals("test_table", DbUtil.getTableName(Testbean.class));
+ Assert.assertEquals("Bar", DbUtil.getTableName(Bar.class));
+ }
+
+ @SuppressWarnings("unchecked")
+ @Before
+ public void setup() throws SecurityException, NoSuchFieldException,
+ IllegalArgumentException, IllegalAccessException {
+ Field globalLocks = DbUtil.class
+ .getDeclaredField("s_connectionForGlobalLocks");
+ globalLocks.setAccessible(true);
+ connectionMapBackup = (Map<String, Connection>) globalLocks.get(null);
+ connectionMap = new HashMap<String, Connection>();
+ globalLocks.set(null, connectionMap);
+
+ Field dsField = TransactionLegacy.class.getDeclaredField("s_ds");
+ dsField.setAccessible(true);
+ backup = (DataSource) dsField.get(null);
+ dsField.set(null, dataSource);
+ }
+
+ @After
+ public void cleanup() throws SecurityException, NoSuchFieldException,
+ IllegalArgumentException, IllegalAccessException {
+ Field globalLocks = DbUtil.class
+ .getDeclaredField("s_connectionForGlobalLocks");
+ globalLocks.setAccessible(true);
+ globalLocks.set(null, connectionMapBackup);
+
+ Field dsField = TransactionLegacy.class.getDeclaredField("s_ds");
+ dsField.setAccessible(true);
+ dsField.set(null, backup);
+ }
+
+ @Test
+ public void getGlobalLock() throws SQLException {
+ Mockito.when(dataSource.getConnection()).thenReturn(connection);
+ Mockito.when(connection.prepareStatement(Mockito.anyString()))
+ .thenReturn(preparedStatement);
+ Mockito.when(preparedStatement.executeQuery()).thenReturn(resultSet);
+ Mockito.when(resultSet.first()).thenReturn(true);
+ Mockito.when(resultSet.getInt(1)).thenReturn(1);
+ Assert.assertTrue(DbUtil.getGlobalLock("TEST", 600));
+
+ Mockito.verify(connection).prepareStatement(Mockito.anyString());
+ Mockito.verify(preparedStatement).close();
+ Mockito.verify(resultSet).close();
+ }
+
+ @Test
+ public void getGlobalLockTimeout() throws SQLException {
+ Mockito.when(dataSource.getConnection()).thenReturn(connection);
+ Mockito.when(connection.prepareStatement(Mockito.anyString()))
+ .thenReturn(preparedStatement);
+ Mockito.when(preparedStatement.executeQuery()).thenReturn(resultSet);
+ Mockito.when(resultSet.first()).thenReturn(true);
+ Mockito.when(resultSet.getInt(1)).thenReturn(0);
+ Assert.assertFalse(DbUtil.getGlobalLock("TEST", 600));
+
+ Mockito.verify(connection).prepareStatement(Mockito.anyString());
+ Mockito.verify(preparedStatement).close();
+ Mockito.verify(resultSet).close();
+ Mockito.verify(connection).close();
+
+ // if any error happens, the connection map must be cleared
+ Assert.assertTrue(connectionMap.isEmpty());
+ }
+
+ @Test
+ public void closeNull() {
+ DbUtil.closeStatement((Statement) null);
+ DbUtil.closeConnection((Connection) null);
+ DbUtil.closeResultSet((ResultSet) null);
+ // no exception should be thrown
+ }
+
+ @Test
+ public void closeConnection() throws IOException, SQLException {
+ DbUtil.closeConnection(connection);
+ Mockito.verify(connection).close();
+ }
+
+ @Test
+ public void closeConnectionFail() throws IOException, SQLException {
+ Mockito.doThrow(new SQLException("it is all right")).when(connection)
+ .close();
+ DbUtil.closeConnection(connection);
+ Mockito.verify(connection).close();
+ }
+
+ @Test
+ public void closeStatement() throws IOException, SQLException {
+ DbUtil.closeStatement(statement);
+ Mockito.verify(statement).close();
+ }
+
+ @Test
+ public void closeStatementFail() throws IOException, SQLException {
+ Mockito.doThrow(new SQLException("it is all right")).when(statement)
+ .close();
+ DbUtil.closeStatement(statement);
+ Mockito.verify(statement).close();
+ }
+
+ @Test
+ public void closeResultSet() throws IOException, SQLException {
+ DbUtil.closeResultSet(resultSet);
+ Mockito.verify(resultSet).close();
+ }
+
+ @Test
+ public void closeResultSetFail() throws IOException, SQLException {
+ Mockito.doThrow(new SQLException("it is all right")).when(resultSet)
+ .close();
+ DbUtil.closeResultSet(resultSet);
+ Mockito.verify(resultSet).close();
+ }
+
+ @Test
+ @Ignore
+ //can not be performed since assertion embedded in this branch of execution
+ public void releaseGlobalLockNotexisting() throws SQLException {
+ Assert.assertFalse(DbUtil.releaseGlobalLock("notexisting"));
+ Mockito.verify(dataSource, Mockito.never()).getConnection();
+ }
+
+ @Test
+ public void releaseGlobalLock() throws SQLException {
+ Mockito.when(connection.prepareStatement(Mockito.anyString()))
+ .thenReturn(preparedStatement);
+ Mockito.when(preparedStatement.executeQuery()).thenReturn(resultSet);
+ Mockito.when(resultSet.first()).thenReturn(true);
+ Mockito.when(resultSet.getInt(1)).thenReturn(1);
+ connectionMap.put("testLock", connection);
+ Assert.assertTrue(DbUtil.releaseGlobalLock("testLock"));
+
+ Mockito.verify(resultSet).close();
+ Mockito.verify(preparedStatement).close();
+ Mockito.verify(connection).close();
+ Assert.assertFalse(connectionMap.containsKey("testLock"));
+ }
+
}