How to use

close

method

in

com.j256.ormlite.support.DatabaseConnection

@Override
public void close() throws IOException {
  if (proxy != null) {
    proxy.close();
  }
}

@Test
public void testCloseQuietly() throws Exception {
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  conn.closeQuietly();
  conn.close();
  DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn);
  replay(conn);
  proxy.closeQuietly();
  proxy.close();
  verify(conn);
}

@Override
public void close() throws IOException {
  if (connection != null) {
    connection.close();
    connection = null;
  }
}

@Test
public void testClose() throws Exception {
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  conn.close();
  DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn);
  replay(conn);
  proxy.close();
  verify(conn);
}

@Test
public void testSetSavePoint() throws Exception {
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  String name = "savepoint";
  expect(conn.setSavePoint(name)).andReturn(null);
  conn.close();
  DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn);
  replay(conn);
  proxy.setSavePoint(name);
  proxy.close();
  verify(conn);
}

@Test
public void testIsAutoCommitSupported() throws Exception {
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  boolean supported = true;
  expect(conn.isAutoCommitSupported()).andReturn(supported);
  conn.close();
  DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn);
  replay(conn);
  assertEquals(supported, proxy.isAutoCommitSupported());
  proxy.close();
  verify(conn);
}

@Test
public void testIsClosed() throws Exception {
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  boolean closed = true;
  expect(conn.isClosed()).andReturn(closed);
  conn.close();
  DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn);
  replay(conn);
  assertEquals(closed, proxy.isClosed());
  proxy.close();
  verify(conn);
}

@Test
public void testIsAutoCommit() throws Exception {
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  boolean autoCommit = false;
  expect(conn.isAutoCommit()).andReturn(autoCommit);
  conn.close();
  DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn);
  replay(conn);
  assertEquals(autoCommit, proxy.isAutoCommit());
  proxy.close();
  verify(conn);
}

@Test
public void testExecuteStatement() throws Exception {
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  String statement = "select foo from bar";
  int result = 1312321;
  expect(conn.executeStatement(statement, 0)).andReturn(result);
  conn.close();
  DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn);
  replay(conn);
  assertEquals(result, proxy.executeStatement(statement, 0));
  proxy.close();
  verify(conn);
}

@Test
public void testInsert() throws Exception {
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  String statement = "insert bar";
  int result = 13712321;
  expect(conn.insert(statement, null, null, null)).andReturn(result);
  conn.close();
  DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn);
  replay(conn);
  assertEquals(result, proxy.insert(statement, null, null, null));
  proxy.close();
  verify(conn);
}

@Test
public void testUpdate() throws Exception {
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  String statement = "insert bar";
  int result = 13212321;
  expect(conn.update(statement, null, null)).andReturn(result);
  conn.close();
  DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn);
  replay(conn);
  assertEquals(result, proxy.update(statement, null, null));
  proxy.close();
  verify(conn);
}

@Test
public void testSetAutoCommit() throws Exception {
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  boolean autoCommit = false;
  conn.setAutoCommit(autoCommit);
  conn.close();
  DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn);
  replay(conn);
  proxy.setAutoCommit(autoCommit);
  proxy.close();
  verify(conn);
}

@Test
public void testRollback() throws Exception {
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  conn.rollback(null);
  conn.close();
  DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn);
  replay(conn);
  proxy.rollback(null);
  proxy.close();
  verify(conn);
}

@Test
public void testCommit() throws Exception {
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  conn.commit(null);
  conn.close();
  DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn);
  replay(conn);
  proxy.commit(null);
  proxy.close();
  verify(conn);
}

@Test
public void testReleaseAlreadyClosed() throws Exception {
  JdbcPooledConnectionSource pooled = new JdbcPooledConnectionSource(DEFAULT_DATABASE_URL);
  try {
    DatabaseConnection conn1 = pooled.getReadOnlyConnection(null);
    conn1.close();
    pooled.releaseConnection(conn1);
  } finally {
    pooled.close();
  }
}

@Test(expected = SQLException.class)
public void testCreateThrow() throws Exception {
  Dao<Foo, Integer> dao = createDao(Foo.class, true);
  Foo foo = new Foo();
  DatabaseConnection conn = connectionSource.getReadWriteConnection(FOO_TABLE_NAME);
  try {
    conn.close();
    dao.create(foo);
  } finally {
    connectionSource.releaseConnection(conn);
  }
}

@Test(expected = SQLException.class)
public void testQueryRawStringsThrow() throws Exception {
  Dao<Foo, Integer> dao = createDao(Foo.class, true);
  Foo foo = new Foo();
  assertEquals(1, dao.create(foo));
  DatabaseConnection conn = connectionSource.getReadWriteConnection(FOO_TABLE_NAME);
  try {
    conn.close();
    dao.queryRaw("SELECT * FROM FOO");
  } finally {
    connectionSource.releaseConnection(conn);
  }
}

@Test(expected = SQLException.class)
public void testUpdateRawThrow() throws Exception {
  Dao<Foo, Integer> dao = createDao(Foo.class, true);
  Foo foo = new Foo();
  assertEquals(1, dao.create(foo));
  DatabaseConnection conn = connectionSource.getReadWriteConnection(FOO_TABLE_NAME);
  try {
    conn.close();
    dao.updateRaw("DELETE FROM FOO");
  } finally {
    connectionSource.releaseConnection(conn);
  }
}

@Test(expected = SQLException.class)
public void testUpdateThrow() throws Exception {
  Dao<Foo, Integer> dao = createDao(Foo.class, true);
  Foo foo = new Foo();
  assertEquals(1, dao.create(foo));
  DatabaseConnection conn = connectionSource.getReadWriteConnection(FOO_TABLE_NAME);
  try {
    conn.close();
    dao.update(foo);
  } finally {
    connectionSource.releaseConnection(conn);
  }
}

@Test(expected = SQLException.class)
public void testIteratorPreparedThrow() throws Exception {
  Dao<Foo, Integer> dao = createDao(Foo.class, true);
  Foo foo = new Foo();
  assertEquals(1, dao.create(foo));
  DatabaseConnection conn = connectionSource.getReadWriteConnection(FOO_TABLE_NAME);
  try {
    conn.close();
    dao.iterator(dao.queryBuilder().prepare());
  } finally {
    connectionSource.releaseConnection(conn);
  }
}