private <T extends Annotation> Collection<T> getAnnotations( DbUnitTestContext testContext, Class<T> annotationType) { List<T> annotations = new ArrayList<T>(); addAnnotationToList( annotations, AnnotationUtils.findAnnotation(testContext.getTestClass(), annotationType)); addAnnotationToList( annotations, AnnotationUtils.findAnnotation(testContext.getTestMethod(), annotationType)); return annotations; }
private IDataSet loadDataset(DbUnitTestContext testContext, String dataSetLocation) throws Exception { DataSetLoader dataSetLoader = testContext.getDataSetLoader(); if (StringUtils.hasLength(dataSetLocation)) { IDataSet dataSet = dataSetLoader.loadDataSet(testContext.getTestClass(), dataSetLocation); Assert.notNull( dataSet, "Unable to load dataset from \"" + dataSetLocation + "\" using " + dataSetLoader.getClass()); return dataSet; } return null; }
private void setupOrTeardown( DbUnitTestContext testContext, boolean isSetup, Collection<AnnotationAttributes> annotations) throws Exception { IDatabaseConnection connection = testContext.getConnection(); DatabaseOperation lastOperation = null; for (AnnotationAttributes annotation : annotations) { for (String dataSetLocation : annotation.getValue()) { DatabaseOperation operation = annotation.getType(); org.dbunit.operation.DatabaseOperation dbUnitDatabaseOperation = getDbUnitDatabaseOperation(testContext, operation, lastOperation); IDataSet dataSet = loadDataset(testContext, dataSetLocation); if (dataSet != null) { if (logger.isDebugEnabled()) { logger.debug( "Executing " + (isSetup ? "Setup" : "Teardown") + " of @DatabaseTest using " + operation + " on " + dataSetLocation); } dbUnitDatabaseOperation.execute(connection, dataSet); lastOperation = operation; } } } }
@AroundInvoke public Object execute(InvocationContext invocationContext) throws Exception { // Execute following logic only if @Test method Test testAnnotation = invocationContext.getMethod().getAnnotation(Test.class); if (testAnnotation == null) { return invocationContext.proceed(); } dbUnitSetup(); DbUnitTestContext testContext = new DbUnitTestContext(); Object returnValue = null; Class<?> testClass = ProxyUtils.getUnproxiedClass(invocationContext.getTarget().getClass()); testContext.setTestClass(testClass); testContext.setTestInstance(invocationContext.getTarget()); testContext.setTestMethod(invocationContext.getMethod()); DbUnitConfiguration dbUnitConfiguration = testClass.getAnnotation(DbUnitConfiguration.class); try { dbUnitRunner.prepareTesterSetup(testContext, dbUnitConfiguration, databaseTester); // try { databaseTester.onSetup(); // } catch (Throwable e) { // do not propagate db setup exception or transaction // will not rollback // e.printStackTrace(); // } returnValue = invocationContext.proceed(); dbUnitRunner.verifyExpected(testContext); } finally { dbUnitRunner.prepareTesterTearDown(testContext, dbUnitConfiguration, databaseTester); databaseTester.onTearDown(); try { if (connection != null) { connection.close(); } } catch (Exception e) { connection = null; } } return returnValue; }
/** * Called after a test method is executed to perform any database teardown and to check expected * results. * * @param testContext The test context * @throws Exception */ public void afterTestMethod(DbUnitTestContext testContext) throws Exception { try { verifyExpected(testContext, getAnnotations(testContext, ExpectedDatabase.class)); Collection<DatabaseTearDown> annotations = getAnnotations(testContext, DatabaseTearDown.class); try { setupOrTeardown(testContext, false, AnnotationAttributes.get(annotations)); } catch (RuntimeException e) { if (testContext.getTestException() == null) { throw e; } if (logger.isWarnEnabled()) { logger.warn("Unable to throw database cleanup exception due to existing test error", e); } } } finally { testContext.getConnection().close(); } }
private org.dbunit.operation.DatabaseOperation getDbUnitDatabaseOperation( DbUnitTestContext testContext, DatabaseOperation operation, DatabaseOperation lastOperation) { if ((operation == DatabaseOperation.CLEAN_INSERT) && (lastOperation == DatabaseOperation.CLEAN_INSERT)) { operation = DatabaseOperation.INSERT; } org.dbunit.operation.DatabaseOperation databaseOperation = testContext.getDatbaseOperationLookup().get(operation); Assert.state( databaseOperation != null, "The databse operation " + operation + " is not supported"); return databaseOperation; }
private void verifyExpected( DbUnitTestContext testContext, Collection<ExpectedDatabase> annotations) throws Exception { if (testContext.getTestException() != null) { if (logger.isDebugEnabled()) { logger.debug( "Skipping @DatabaseTest expectation due to test exception " + testContext.getTestException().getClass()); } return; } IDatabaseConnection connection = testContext.getConnection(); IDataSet actualDataSet = connection.createDataSet(); for (ExpectedDatabase annotation : annotations) { IDataSet expectedDataSet = loadDataset(testContext, annotation.value()); if (expectedDataSet != null) { if (logger.isDebugEnabled()) { logger.debug("Veriftying @DatabaseTest expectation using " + annotation.value()); } DatabaseAssertion assertion = annotation.assertionMode().getDatabaseAssertion(); assertion.assertEquals(expectedDataSet, actualDataSet); } } }