Jak na rychlé integrační testy ve Springu

/**
 * Performs the same funcionality as AbstractTransactionalDataSourceSpringContextTests but more than that
 * it contains coherent logic for keeping state of the database in consistency with prepared testing data.
 * See #AbstractTransactionalDataSourceSpringContextTests documentation for more hints on testing.
 */
public abstract class AbstractDatabaseSpringTestCase extends AbstractTransactionalDataSourceSpringContextTests {
	/**
	 * Flag signalizing, that test modified data in database outside transaction, but the rowcount
	 * in tables stood the same.
	 */
	private static boolean databaseIsDirty;
	/**
	 * Subclasses can override this method to perform any setup operations,
	 * such as populating a database table, before the transaction
	 * created by this class. Only invoked if there is a transaction:
	 * that is, if {@link #preventTransaction()} has not been invoked in
	 * an overridden {@link #runTest()} method.
	 *
	 * @throws Exception simply let any exception propagate
	 */
	protected void onSetUpBeforeTransaction() throws Exception {
		super.onSetUpBeforeTransaction();
		refreshDatabase(true);
	}
	/**
	 * Subclasses can override this method to perform cleanup after a transaction
	 * here. At this point, the transaction is not active anymore.
	 *
	 * @throws Exception simply let any exception propagate
	 */
	protected void onTearDownAfterTransaction() throws Exception {
		super.onTearDownAfterTransaction();
		if(databaseIsDirty) refreshDatabase(false);
	}
	/**
	 * Performs refresh of the data in database.
	 * @param checkCounts when true check whether counts in tables has changed
	 *        - if not skip refreshment
	 */
	private void refreshDatabase(boolean checkCounts) {
		TableCountHolder[] tablesWithCounts = getTablesToBeCheckedForCount();
		if(tablesWithCounts != null) {
			if(!checkCounts || isDataInconsistent(tablesWithCounts)) {
				String[] tableNames = createTableNames(tablesWithCounts);
				deleteFromTables(tableNames);
				populateEmptyTables();
				databaseIsDirty = false;
			}
		}
	}
	/**
	 * This method should be called by test, when it changes data outside a transaction and
	 * possible does not change rowcount in tables.
	 */
	protected void setDatabaseDirty() {
		AbstractDatabaseSpringTestCase.databaseIsDirty = true;
	}
	/**
	 * Converts set into array of tablenames.
	 *
	 * @param tablesWithCounts
	 * @return
	 */
	private String[] createTableNames(TableCountHolder[] tablesWithCounts) {
		String[] result = new String[tablesWithCounts.length];
		for(int j = 0; j < tablesWithCounts.length; j++) {
			result[j] = tablesWithCounts[j].getTableName();
		}
		return result;
	}
	/**
	 * Returns true if data is not consistent in database.
	 *
	 * @param tablesWithCounts
	 */
	private boolean isDataInconsistent(TableCountHolder[] tablesWithCounts) {
		for(int i = 0; i < tablesWithCounts.length; i++) {
			TableCountHolder tableInfo = tablesWithCounts[i];
			String tableName = tableInfo.getTableName();
			if(tableInfo.getExpectedRowCount() != countRowsInTable(tableName)) {
				logger.info("Table " + tableName + " inconsistent, forcing data refresh.");
				return true;
			}
			else {
				logger.info("Table " + tableName + " consistent, can reuse existing data.");
			}
		}
		return false;
	}
	/**
	 * Method to be overriden by subclasses.
	 * Should populate data into all tables mentioned in getTablesToBeCheckedForCount method.
	 * This class ensures that all tables are emptied before calling this method.
	 */
	protected void populateEmptyTables() {
		//let the subclass do what it needs
	}
	/**
	 * Method to be overriden by subclasses.
	 *
	 * It is important to have items in array in right order optimized for
	 * possible record deletion sequence.
	 *
	 * @return
	 */
	protected TableCountHolder[] getTablesToBeCheckedForCount() {
		return null;
	}
	/**
	 * Holds information about expected rowcount in a table.
	 */
	public static class TableCountHolder {
		private String tableName;
		private int expectedRowCount;
		public TableCountHolder(String tableName, int expectedRowCount) {
			this.tableName = tableName;
			this.expectedRowCount = expectedRowCount;
		}
		public String getTableName() {
			return tableName;
		}
		public void setTableName(String tableName) {
			this.tableName = tableName;
		}
		public int getExpectedRowCount() {
			return expectedRowCount;
		}
		public void setExpectedRowCount(int expectedRowCount) {
			this.expectedRowCount = expectedRowCount;
		}
	}
}

/**
 * Project database test ancestor. Contains database population logic.
 */
public abstract class AbstractProjectDatabaseTestCase extends AbstractDatabaseSpringTestCase {
	protected SqlMapClient sqlMapClient;
	protected IRoleStorage daoRole = null;
	protected static IRole[] roles = new IRole[]{
		//creates populated POJO Role object: id, systemName, name, description
		PojoFactory.getRole(1, "SUPERVIZOR", "Oprávnění supervizora", "Role s maximálními oprávněními."),
		PojoFactory.getRole(2, "ADMINISTRATOR", "Administrátor", "Administrační práva."),
		PojoFactory.getRole(3, "PUBLISHER", "Pisatel", "Umožňuje psát články."),
		PojoFactory.getRole(4, "READER", "Čtenář", "Umožňuje číst články."),
		PojoFactory.getRole(5, "REDACTOR", "Redaktor", "Schvaluje články.")
	};
	public void setDaoRole(IRoleStorage daoRole) {
		this.daoRole = daoRole;
	}
	public void setSqlMapClient(SqlMapClient sqlMapClient) {
		this.sqlMapClient = sqlMapClient;
	}
	protected void populateEmptyTables() {
		try {
			for(int i = 0; i < roles.length; i++) daoRole.createRole(roles[i]);
		}
		catch(Exception ex) {
			throw new RuntimeException("Cannot prepare database for tests!", ex);
		}
	}
	protected TableCountHolder[] getTablesToBeCheckedForCount() {
		return new TableCountHolder[]{
				new TableCountHolder("T_FGUSER_AUTHORITY", roles.length),
	}
}

public class RoleStorageTest extends AbstractProjectDatabaseTestCase {
	public void testCreateRole() throws Exception {
		IRole role = getSomeNewRole();
		daoRole.createRole(role);
		assertTrue(role.getId() > 0);
	}
	public void testCreateRoleTwice() throws Exception {
		IRole role = ((Role)roles[0]).getClone();
		try {
			role.setId(0);
			daoRole.createRole(role);
			fail("Exception should have been thrown.");
		}
		catch(ObjectAlreadyExists e) {
			//yup, this is right
		}
	}
	public void testGetRoleNonExisting() throws Exception {
		assertNull(daoRole.getRoleById(-1));
		assertNull(daoRole.getRoleBySystemName("nejaka nesmyslna"));
	}
	public void testGetRoleById() throws Exception {
		IRole role = daoRole.getRoleById(roles[0].getId());
		assertTrue("Roles should be the same", roles[0].match(role));
	}
	public void testGetRoleBySystemName() throws Exception {
		IRole role = daoRole.getRoleBySystemName(roles[0].getSystemName());
		assertTrue("Roles should be the same", roles[0].match(role));
	}
	public void testUpdateRole() throws Exception {
		Role role = ((Role)roles[0]).getClone();
		int id = role.getId();
		role.setSystemName("WHATEVER");
		role.setName("Whatever name");
		role.setDescription("Whatever description");
		daoRole.updateRole(role);
		IRole role2 = daoRole.getRoleBySystemName("WHATEVER");
		assertTrue("Roles should be the same", role.match(role2));
		assertEquals(id, role2.getId());
	}
	public void testRemoveRole() throws Exception {
		assertTrue(daoRole.removeRole(roles[0].getId()));
		assertNull(daoRole.getRoleBySystemName(roles[0].getSystemName()));
	}
	public void testRemoveRoleNonExisting() throws Exception {
		assertFalse(daoRole.removeRole(-1));
	}
	public void testListRoles() throws Exception {
		List list;
		list = daoRole.listRoles(new HashMap(), null, null, 0, 20);
		assertNotNull(list);
		assertTrue(list.size() == users.length);
		assertEquals("ADMINISTRATOR", ((IRole)list.get(0)).getSystemName());
		list = daoRole.listRoles(new HashMap(), RoleStorage.ORDER_BY_DESCRIPTION, Boolean.FALSE, 0, 20);
		assertEquals("PUBLISHER", ((IRole)list.get(0)).getSystemName());
		HashMap conditions = new HashMap();
		conditions.put("description", "Umožňuje%");
		list = daoRole.listRoles(conditions, null, null, 0, 20);
		assertTrue(list.size() == 2);
	}
	private IRole getSomeNewRole() {
		return PojoFactory.getRole("EVICTOR", "Mazač", "Role která umožňuje mazání.");
	}
}