Java DataSetFactory类代码示例

import org.unitils.dbunit.datasetfactory.DataSetFactory; //导入依赖的package包/类
public static void assertExpectedDataSet(final String... datasetFile) {
    TestContext testContext = Unitils.getInstance().getTestContext();
    ExpectedDataSet expectedDataSetAnnotation = new ExpectedDataSet() {

        @Override
        public Class<? extends Annotation> annotationType() {
            return ExpectedDataSet.class;
        }

        @Override
        public String[] value() {
            return datasetFile;
        }

        @Override
        public Class<? extends DataSetFactory> factory() {
            return null;
        }

        @Override
        public String databaseName() {
            return null;
        }
    };
    getDbUnitModule().assertExpectedDataSets(expectedDataSetAnnotation , testContext.getTestObject(), testContext.getTestMethod());
}
 

import org.unitils.dbunit.datasetfactory.DataSetFactory; //导入依赖的package包/类
/**
 * Returns the {@link MultiSchemaDataSet} that represents the state of a number of database tables after the given <code>Method</code>
 * has been executed.
 *
 * @param testMethod The test method, not null
 * @param testObject The test object, not null
 * @return The dataset, null if there is no data set
 */
public MultiSchemaDataSet getExpectedDataSet(ExpectedDataSet expectedDataSetAnnotation, Method testMethod, Object testObject) {


    databaseName = expectedDataSetAnnotation.databaseName();

    // Create configured factory for data sets
    DataSetFactory dataSetFactory = getDataSetFactory(ExpectedDataSet.class, testMethod, testObject.getClass());

    // Get the dataset file name
    String[] dataSetFileNames = expectedDataSetAnnotation.value();
    if (dataSetFileNames.length == 0) {
        // empty means use default file name
        dataSetFileNames = new String[]{
            createDataSetFileNamesHandler().getDefaultExpectedDataSetFileName(testMethod, testObject.getClass(), dataSetFactory.getDataSetFileExtension())
        };
    }

    return getDataSet(testMethod.getDeclaringClass(), dataSetFileNames, dataSetFactory);
}
 

import org.unitils.dbunit.datasetfactory.DataSetFactory; //导入依赖的package包/类
/**
 * Creates the dataset for the given file. Filenames that start with '/' are treated absolute. Filenames that do not start with '/', are
 * relative to the current class.
 *
 * @param testClass The test class, not null
 * @param dataSetFileNames The names of the files, (start with '/' for absolute names), not null, not empty
 * @param dataSetFactory DataSetFactory responsible for creating the dataset file
 * @return The data set, null if the file does not exist
 */
protected MultiSchemaDataSet getDataSet(Class<?> testClass, String[] dataSetFileNames, DataSetFactory dataSetFactory) {
    List<File> dataSetFiles = new ArrayList<File>();

    ResourcePickingStrategie resourcePickingStrategie = getResourcePickingStrategie();

    for (String dataSetFileName : dataSetFileNames) {
        File dataSetFile = createDataSetFileNamesHandler().locateResource(new ClassPathDataLocator(), dataSetFileName, resourcePickingStrategie, testClass);
        dataSetFiles.add(dataSetFile);
    }

    logger.info("Loading DbUnit data set. File names: " + dataSetFiles);
    MultiSchemaDataSet dataSet = dataSetFactory.createDataSet(dataSetFiles.toArray(new File[dataSetFiles.size()]));
    getFileHandler().deleteFiles(dataSetFiles);
    return dataSet;
}
 

import org.unitils.dbunit.datasetfactory.DataSetFactory; //导入依赖的package包/类
/**
 * Inserts the default dataset for the given test class into the database
 *
 * @param testClass The test class for which the default dataset must be loaded
 */
public void insertDefaultDataSet(Class<?> testClass) {
    DataSetFactory dataSetFactory = getDefaultDataSetFactory();
    String[] dataSetFileNames = new String[]{
        createDataSetFileNamesHandler().getDefaultDataSetFileNameClassLevel(testClass, dataSetFactory.getDataSetFileExtension())
    };
    insertDataSet(testClass, dataSetFileNames);
}
 

import org.unitils.dbunit.datasetfactory.DataSetFactory; //导入依赖的package包/类
/**
 * Inserts the dataset consisting of the given list of files into the database
 *
 * @param testClass The test class for which the dataset must be loaded
 * @param dataSetFileNames The names of the files that define the test data
 */
public void insertDataSet(Class<?> testClass, String... dataSetFileNames) {
    DataSetFactory dataSetFactory = getDefaultDataSetFactory();
    DataSetLoadStrategy dataSetLoadStrategy = getDefaultDataSetLoadStrategy();
    MultiSchemaDataSet dataSet = getDataSet(testClass, dataSetFileNames, dataSetFactory);
    insertDataSet(dataSet, dataSetLoadStrategy);
}
 

import org.unitils.dbunit.datasetfactory.DataSetFactory; //导入依赖的package包/类
public void insertDataSets(DataSets dataSets, Object testObject, Method testMethod) {
    Map<String, List<DataSet>> sortedDataSets = getDataSetsSorted(dataSets);
    for (List<DataSet> tempDataSets : sortedDataSets.values()) {
        boolean cleanLoadStrategy = false;
        for (final DataSet dataSet : tempDataSets) {
            DataSetLoadStrategy loadStrategy = getDataSetLoadStrategy(testMethod, testObject.getClass(), dataSet);
            if (loadStrategy instanceof CleanInsertLoadStrategy && !cleanLoadStrategy) {
                cleanLoadStrategy = true;
                insertDataSet(dataSet, testObject, testMethod);
            } else if (loadStrategy instanceof CleanInsertLoadStrategy && cleanLoadStrategy) {
                DataSet newDataSet = new DataSet() {

                    @Override
                    public Class<? extends Annotation> annotationType() {
                        return dataSet.annotationType();
                    }

                    @Override
                    public String[] value() {
                        return dataSet.value();
                    }

                    @Override
                    public Class<? extends DataSetLoadStrategy> loadStrategy() {
                        return InsertLoadStrategy.class;
                    }

                    @Override
                    public Class<? extends DataSetFactory> factory() {
                        return dataSet.factory();
                    }

                    @Override
                    public String databaseName() {
                        return dataSet.databaseName();
                    }
                };
                insertDataSet(newDataSet, testObject, testMethod);
            } else {
                insertDataSet(dataSet, testObject, testMethod);
            }
        }
    }


}
 

import org.unitils.dbunit.datasetfactory.DataSetFactory; //导入依赖的package包/类
/**
 * @return The default {@link DataSetFactory} class as configured in unitils
 */
protected DataSetFactory getDefaultDataSetFactory() {
    Class<? extends DataSetFactory> dataSetFactoryClass = getClassWithName(getAnnotationPropertyDefault(DbUnitModule.class, DataSet.class, "factory", configuration));
    return getDataSetFactory(dataSetFactoryClass);
}
 

import org.unitils.dbunit.datasetfactory.DataSetFactory; //导入依赖的package包/类
/**
 * Get the configured DataSetFactory for the given method
 *
 * @param annotationClass The class of the annotation, i.e. DataSet.class or ExpectedDataSet.class
 * @param testMethod The method for which we need the configured DataSetFactory
 * @param testClass The class that is looked for class-level annotations
 * @return The configured DataSetFactory
 */
@SuppressWarnings("unchecked")
protected DataSetFactory getDataSetFactory(Class<? extends Annotation> annotationClass, Method testMethod, Class<?> testClass) {
    Class<? extends DataSetFactory> dataSetFactoryClass = getMethodOrClassLevelAnnotationProperty(annotationClass, "factory", DataSetFactory.class, testMethod, testClass);
    dataSetFactoryClass = (Class<? extends DataSetFactory>) getClassValueReplaceDefault(annotationClass, "factory", dataSetFactoryClass, defaultAnnotationPropertyValues, DataSetFactory.class);
    return getDataSetFactory(dataSetFactoryClass);
}
 

import org.unitils.dbunit.datasetfactory.DataSetFactory; //导入依赖的package包/类
/**
 * Inserts the test data coming from the given DbUnit dataset file.
 *
 * @param dataSetFile              The test data set, not null
 * @param dataSetFactoryClass      The class of the factory that must be used to read this dataset
 * @param dataSetLoadStrategyClass The class of the load strategy that must be used to load this dataset
 */
public static void insertDataSet(File dataSetFile, Class<? extends DataSetFactory> dataSetFactoryClass, Class<? extends DataSetLoadStrategy> dataSetLoadStrategyClass) {
    getDbUnitModule().insertDataSet(dataSetFile, dataSetFactoryClass, dataSetLoadStrategyClass);
}