nitils.1.0.source-code.unitils-default.properties Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of unitils Show documentation
Show all versions of unitils Show documentation
Unitils provides utilities to further simplify unit-testing with JUnit, DBUnit, EasyMock
Hibernate and Spring. The goal is to make unit-testing easy and maintainable by offering
utilities such as automatic DB-schema maintainance and equality assertion through reflection.
####################################
# Default configuration of Unitils #
####################################
# This file contains default configuration values for unitils. This file should not be edited.
# All properties in this file can be overridden, either in the project specific properties file
# (unitils.properties) or in the local properties file (configured by unitils.configuration.customFileName).
# Name or path of the project specific properties file. The system will try to find this file in the classpath (recommended),
# the user home folder or the local filesystem
unitils.configuration.customFileName=unitils.properties
# Name or path of the user specific properties file. This file should contain the necessary parameters to connect to the
# developer's own unit test schema. It is recommended to override the name of this file in the project specific properties
# file, to include the name of the project. The system will try to find this file in the classpath, the user home folder
# (recommended) or the local filesystem.
unitils.configuration.localFileName=unitils-local.properties
# List of modules that is loaded. Overloading this list is normally not useful, unless you want to add a custom written
# module. Disabling a module can be performed by setting unitils.module..enabled to false.
# If a module's specific dependencies are not found (e.g. hibernate is not in you classpath), this module is not loaded,
# even if it is in this list and the enabled property is set to true. It's therefore not strictly necessary to disable
# any of these modules.
unitils.modules=database,dbunit,hibernate,easymock,inject,spring
#### Unitils core configuration ###
# For each module, the implementation class is listed in unitils.module..className, the sequence of the
# execution of their code is influenced by unitils.module..runAfter. Disabling a module can be performed by
# setting unitils.module..enabled to false.
unitils.module.database.className=org.unitils.database.DatabaseModule
unitils.module.database.runAfter=
unitils.module.database.enabled=true
unitils.module.hibernate.className=org.unitils.hibernate.HibernateModule
unitils.module.hibernate.runAfter=
unitils.module.hibernate.enabled=true
unitils.module.dbunit.className=org.unitils.dbunit.DbUnitModule
unitils.module.dbunit.runAfter=
unitils.module.dbunit.enabled=true
unitils.module.easymock.className=org.unitils.easymock.EasyMockModule
unitils.module.easymock.runAfter=
unitils.module.easymock.enabled=true
unitils.module.inject.className=org.unitils.inject.InjectModule
unitils.module.inject.runAfter=
unitils.module.inject.enabled=true
unitils.module.spring.className=org.unitils.spring.SpringModule
unitils.module.spring.runAfter=database
unitils.module.spring.enabled=true
### DatabaseModule Configuration ###
## Full qualified class name of an implementation of org.unitils.database.config.DataSourceFactory. This class is used
# to provide a DataSource for all database unit tests and for the DBMaintainer.
org.unitils.database.config.DataSourceFactory.implClassName=org.unitils.database.config.PropertiesDataSourceFactory
# Properties for the PropertiesDataSourceFactory
database.driverClassName=
database.url=
database.userName=
database.password=
# This property specifies the underlying DBMS implementation. Supported values are 'oracle', 'db2', 'mysql', 'hsqldb',
# 'postgresql' and 'derby'. The value of this property defines which vendor specific implementations of DbSupport and
# ConstraintsDisabler are chosen.
database.dialect=
# A comma-separated list of all used database schemas. The first schema name is the default one, if no schema name is
# specified in for example a dbunit data set, this default one is used.
# A schema name is case sensitive if it's surrounded by database identifier quotes (eg " for oracle)
database.schemaNames=
### DatabaseModule's DbMaintainer configuration ###
# If set to true, the DBMaintainer will be used to update the unit test database schema. This is done once for each
# test run, when creating the DataSource that provides access to the unit test database.
updateDataBaseSchema.enabled=false
# Indicates the database must be recreated from scratch when an already executed script is updated. If false, the
# DBMaintainer will give an error when an existing script is updated.
dbMaintainer.fromScratch.enabled=true
# Indicates whether a from scratch update should be performed when the previous update failed, but
# none of the scripts were modified since that last update. If false a new update will be tried only when
# changes were made to the script files.
dbMaintainer.keepRetryingAfterError.enabled=true
# Indicates whether database code like triggers, types, packages, functions and stored procedures should be cleared from
# the database before installing a new version of the database code (stored procedures and functions - configured using
# the property dbMaintainer.fileScriptSource.code.locations). When clearing the database (when creating from scratch) the
# database code is cleared anyway, even when this property is set to false
dbMaintainer.clearDbCode.enabled=true
# Fully qualified classnames of implementations of org.unitils.core.dbsupport.DbSupport.
org.unitils.core.dbsupport.DbSupport.implClassName.oracle=org.unitils.core.dbsupport.OracleDbSupport
org.unitils.core.dbsupport.DbSupport.implClassName.hsqldb=org.unitils.core.dbsupport.HsqldbDbSupport
org.unitils.core.dbsupport.DbSupport.implClassName.mysql=org.unitils.core.dbsupport.MySqlDbSupport
org.unitils.core.dbsupport.DbSupport.implClassName.db2=org.unitils.core.dbsupport.Db2DbSupport
org.unitils.core.dbsupport.DbSupport.implClassName.postgresql=org.unitils.core.dbsupport.PostgreSqlDbSupport
org.unitils.core.dbsupport.DbSupport.implClassName.derby=org.unitils.core.dbsupport.DerbyDbSupport
# Determines how the database stores non-quoted identifiers
# Possible values are lower_case, upper_case, mixed_case and auto
# If auto is specified, the database metadata is used to determine the correct value
database.storedIndentifierCase.oracle=auto
database.storedIndentifierCase.hsqldb=auto
database.storedIndentifierCase.mysql=auto
database.storedIndentifierCase.db2=auto
database.storedIndentifierCase.postgresql=auto
database.storedIndentifierCase.derby=auto
# Determines the string the database uses to quote identifiers, i.e. make them case-sensitive
# Leave empty if quoting is not supported.
# If auto is specified, the database metadata is used to determine the correct value
database.identifierQuoteString.oracle=auto
database.identifierQuoteString.hsqldb=auto
database.identifierQuoteString.mysql=auto
database.identifierQuoteString.db2=auto
database.identifierQuoteString.postgresql=auto
database.identifierQuoteString.derby=auto
# Fully qualified name of the implementation of org.unitils.dbmaintainer.maintainer.version.VersionSource that is used.
# The default value is 'org.unitils.dbmaintainer.maintainer.version.DBVersionSource', which retrieves the database version
# from the updated database schema itself. Another implementation could e.g. retrieve the version from a file.
org.unitils.dbmaintainer.version.VersionSource.implClassName=org.unitils.dbmaintainer.version.impl.DBVersionSource
# Name of the table that contains the version of the database. The version info is stored in the first row of this table,
# in the columns defined by the properties dbMaintainer.dbVersionSource.versionIndexColumnName,
# dbMaintainer.dbVersionSource.versionTimeStampColumnName, dbMaintainer.dbVersionSource.lastUpdateSucceededColumnName,
# dbMaintainer.dbVersionSource.codeScriptsTimeStampColumnName and dbMaintainer.dbVersionSource.lastCodeUpdateSucceededColumnName
dbMaintainer.dbVersionSource.tableName=db_version
# Name of the column in which the version index of the database is stored. This index refers to the index of the last
# script file that has been executed on the database
dbMaintainer.dbVersionSource.versionIndexColumnName=version_index
# Name of the column in which the version timestamp of the database is stored. This timestamp refers the the highest
# last modification date of the update scripts that have been executed on the database
dbMaintainer.dbVersionSource.versionTimeStampColumnName=version_timestamp
# Name of the column in which is stored whether the last update succeeded or not. If the last update gave an error, and
# dbMaintainer.fromScratch.enabled is set to true, the database will be cleared and rebuilt from scratch during the next
# update
dbMaintainer.dbVersionSource.lastUpdateSucceededColumnName=last_update_succeeded
# Name of the column in which the version timestamp of the database is stored. This timestamp refers the the highest
# last modification date of the code scripts that have been executed on the database
dbMaintainer.dbVersionSource.codeScriptsTimeStampColumnName=codescripts_timestamp
# Name of the column in which is stored whether the last code update succeeded or not.
dbMaintainer.dbVersionSource.lastCodeUpdateSucceededColumnName=last_codeupdate_succeeded
# Set to true if the db version table should be created automatically if it does not exist yet.
# If false, an exception is thrown the it does not exist yet, showing how to create the version table manually.
# This is set to false by default to be sure that no non-unit test schema is dropped by accident. If a
# version table is available, we assume it to be a unit-test schema, if not, you should manually add a version table
# to indicate that it is a unit-test schema.
dbMaintainer.dbVersionSource.autoCreateVersionTable=false
# Fully qualified name of the implementation of org.unitils.dbmaintainer.maintainer.script.ScriptSource that is used.
# The default value is 'org.unitils.dbmaintainer.maintainer.script.FileScriptSource', which will retrieve the scripts
# from the local file system.
org.unitils.dbmaintainer.script.ScriptSource.implClassName=org.unitils.dbmaintainer.script.impl.FileScriptSource
# Extension of the files containing the database update scripts
dbMaintainer.fileScriptSource.scripts.fileExtensions=sql,ddl
# Comma separated list of directories and files in which the database update scripts are located. Directories in this
# list are recursively searched for files.
dbMaintainer.fileScriptSource.scripts.locations=
# Extension of the files containing the database code update scripts
dbMaintainer.fileScriptSource.code.fileExtensions=sql
# Comma separated list of directories and files in which the database code (functions, stored procedures, ...) scripts
# are located. Directories in this list are recursively searched for files.
dbMaintainer.fileScriptSource.code.locations=
# Comma separated list of directories and files in which the post processing database code scripts are
# located. Directories in this list are recursively search for files.
dbMaintainer.fileScriptSource.postProcessingCode.locations=
# Fully qualified name of the implementation of org.unitils.dbmaintainer.script.ScriptRunner that is used. The
# default value is 'org.unitils.dbmaintainer.script.SQLScriptRunner', which executes a regular SQL script.
org.unitils.dbmaintainer.script.ScriptRunner.implClassName=org.unitils.dbmaintainer.script.impl.SQLScriptRunner
org.unitils.dbmaintainer.script.CodeScriptRunner.implClassName=org.unitils.dbmaintainer.script.impl.SQLCodeScriptRunner
# If set to true, an implementation of org.unitils.dbmaintainer.constraints.ConstraintsDisabler will be used to disable
# the foreign key and not null constraints of the unit test database schema.
# The ConstraintsDisabler is configured using the properties specified below. The property with key 'database.dialect'
# specifies which implementation is used.
dbMaintainer.disableConstraints.enabled=true
# Fully qualified classname of the implementation of org.unitils.dbmaintainer.structure.ConstraintsDisabler
org.unitils.dbmaintainer.structure.ConstraintsDisabler.implClassName=org.unitils.dbmaintainer.structure.impl.DefaultConstraintsDisabler
# If set to true, an implementation of org.unitils.dbmaintainer.sequences.SequenceUpdater will be used to update the
# sequences to a suffiently high value, so that test data can be inserted without problems.
# The SequenceUpdater is configured using the properties specified below. The property with key 'database.dialect'
# specifies which implementation is used.
dbMaintainer.updateSequences.enabled=true
# Fully qualified classname of the implementation of org.unitils.dbmaintainer.sequences.SequenceUpdater
org.unitils.dbmaintainer.structure.SequenceUpdater.implClassName=org.unitils.dbmaintainer.structure.impl.DefaultSequenceUpdater
# Lowest acceptable value of a sequence in a unit test database. The SequenceUpdater will make sure all sequences
# have this value or higher before proceeding
sequenceUpdater.sequencevalue.lowestacceptable=1000
# Fully qualified classname of the implementation of org.unitils.dbmaintainer.clear.DBClearer
org.unitils.dbmaintainer.clean.DBClearer.implClassName=org.unitils.dbmaintainer.clean.impl.DefaultDBClearer
# Fully qualified classname of the implementation of org.unitils.dbmaintainer.clear.DBCodeClearer
org.unitils.dbmaintainer.clean.DBCodeClearer.implClassName=org.unitils.dbmaintainer.clean.impl.DefaultDBCodeClearer
# Fully qualified classname of the implementation of org.unitils.dbmaintainer.clean.DBCleaner.
org.unitils.dbmaintainer.clean.DBCleaner.implClassName=org.unitils.dbmaintainer.clean.impl.DefaultDBCleaner
# Indicates whether the database should be cleaned before data updates are executed by the dbMaintainer. If true, the
# records of all database tables, except the ones listed in 'dbMaintainer.preserve.*' are deleted
dbMaintainer.cleanDb.enabled=true
# Comma separated list of database items that may not be dropped or cleared by the db maintainer when
# updating the database from scratch (dbMaintainer.fromScratch.enabled=true).
# Schemas can also be preserved as a whole. If identifiers are quoted (eg "" for oracle) they are considered
# case sensitive. Items that do not have a schema prefix are considered to be in the default schema
dbMaintainer.preserve.schemas=
dbMaintainer.preserve.tables=
dbMaintainer.preserve.views=
dbMaintainer.preserve.synonyms=
dbMaintainer.preserve.sequences=
# Comma separated list of table names. The tables listed here will not be emptied when the db maintainer performs a database
# update. This can be used for Tables that contain rather static, read only or type data. The database version table
# is preserved automatically.
# Tables listed here will still be dropped when the db maintainer performs a from scratch update. If this is not desirable
# you should add the tablename to the dbMaintainer.preserve.tables property instead
# Schemas can also be preserved as a whole. If identifiers are quoted (eg "" for oracle) they are considered
# case sensitive. Items that do not have a schema prefix are considered to be in the default schema
dbMaintainer.preserveDataOnly.schemas=
dbMaintainer.preserveDataOnly.tables=
# If set to true an XSD or DTD will be generated that represents the structure of the database schema. This XSD or DTD can be
# used in datafiles to verify if they are up-to-date and to enable code completion.
dbMaintainer.generateDataSetStructure.enabled=true
# Fully qualified name of the implementation of org.unitils.dbmaintainer.structure.DataSetStructureGenerator that is used.
# org.unitils.dbmaintainer.structure.impl.XsdDataSetStructureGenerator can be used to generate XSDs
# org.unitils.dbmaintainer.structure.impl.DtdDataSetStructureGenerator can be used to generate DTDs
org.unitils.dbmaintainer.structure.DataSetStructureGenerator.implClassName=org.unitils.dbmaintainer.structure.impl.XsdDataSetStructureGenerator
# DbUnit data set dtd file path
dataSetStructureGenerator.dtd.filename=
# DbUnit data set xsd file path
dataSetStructureGenerator.xsd.dirName=
# Suffix to use when generating complex types for tables
dataSetStructureGenerator.xsd.complexTypeSuffix=__type
# Fully qualified classname of the factory for creating the TransactionManager
org.unitils.database.transaction.TransactionManagerFactory.implClassName=org.unitils.database.transaction.impl.DefaultTransactionManagerFactory
### DefaultTransactionManagerFactory configuration ###
# Type of transaction manager that should be created:
# simple: a simple transaction manager that wraps the datasource to control transactions
# spring: a transaction manager that delegats actions to the transaction manager that is configured in the current spring context
# auto: this will first try to load the spring transaction manager. if spring is not available, it will load the simple transaction manager
transactionManager.type=auto
# Fully qualified classnames of the TransactionManager implementations
org.unitils.database.transaction.TransactionManager.implClassName.simple=org.unitils.database.transaction.impl.SimpleTransactionManager
org.unitils.database.transaction.TransactionManager.implClassName.spring=org.unitils.database.transaction.impl.SpringTransactionManager
# Default operation that is used for getting a dbunit dataset into the database. Should be the fully qualified classname
# of an implementation of org.unitils.dbunit.datasetloadstrategy.DataSetLoadStrategy
DbUnitModule.DataSet.loadStrategy.default=org.unitils.dbunit.datasetloadstrategy.impl.CleanInsertLoadStrategy
# Default factory that is used to create a dataset object from a file for the @DataSet annotation
DbUnitModule.DataSet.factory.default=org.unitils.dbunit.datasetfactory.impl.MultiSchemaXmlDataSetFactory
# Default factory that is used to create a dataset object from a file for the @ExpectedDataSet annotation
DbUnitModule.ExpectedDataSet.factory.default=org.unitils.dbunit.datasetfactory.impl.MultiSchemaXmlDataSetFactory
# Fully qualified classname of the data set resolver
org.unitils.dbunit.datasetfactory.DataSetResolver.implClassName=org.unitils.dbunit.datasetfactory.impl.DefaultDataSetResolver
# If set to true, the data set name will be prefixed with the package name of the test (with . replaced by /)
dbUnit.datasetresolver.prefixWithPackageName=true
# Optional prefix for the data set file name. If it starts with '/' it is treated as an absolute path on the
# file system, if not, it is treated as a classpath resource.
dbUnit.datasetresolver.pathPrefix=
# Fully qualified classnames of the different, dbms specific implementations of org.dbunit.dataset.datatype.IDataTypeFactory
org.dbunit.dataset.datatype.IDataTypeFactory.implClassName.oracle=org.dbunit.ext.oracle.OracleDataTypeFactory
org.dbunit.dataset.datatype.IDataTypeFactory.implClassName.db2=org.dbunit.ext.db2.Db2DataTypeFactory
org.dbunit.dataset.datatype.IDataTypeFactory.implClassName.hsqldb=org.dbunit.ext.hsqldb.HsqldbDataTypeFactory
org.dbunit.dataset.datatype.IDataTypeFactory.implClassName.mysql=org.dbunit.ext.mysql.MySqlDataTypeFactory
org.dbunit.dataset.datatype.IDataTypeFactory.implClassName.postgresql=org.dbunit.dataset.datatype.DefaultDataTypeFactory
org.dbunit.dataset.datatype.IDataTypeFactory.implClassName.derby=org.dbunit.dataset.datatype.DefaultDataTypeFactory
### DatabaseModule configuration ###
# Default behavior concerning execution of tests in a transaction. Supported values are 'disabled', 'commit' and 'rollback'.
# If set to disabled, test are not executed in a transaction by default. If set to commit, each test is run in a transaction,
# which is committed. If set to rollback, each test is run in a transaction, which is rolled back.
DatabaseModule.Transactional.value.default=disabled
### EasyMockModule configuration ###
# Default value for order checking of method invocation on mocks. Supported values are 'none' and 'strict'
EasyMockModule.RegularMock.invocationOrder.default=none
# Default value for the calls property of mocks. Supported values are 'lenient' and 'strict'
EasyMockModule.RegularMock.calls.default=strict
# Default value for order checking of method invocation on mocks. Supported values are 'none' and 'strict'
EasyMockModule.Mock.invocationOrder.default=none
EasyMockModule.Mock.calls.default=strict
EasyMockModule.Mock.order.default=lenient
EasyMockModule.Mock.dates.default=strict
EasyMockModule.Mock.defaults.default=ignore_defaults
# Indicates whether after every test, the expected method calls are verified on all mock objects that were injected on
# fields annotated with @Mock or created with EasyMockUnitils.createMock (i.e. the verify() method is invoked on all
# these mocks.
EasyMockModule.autoVerifyAfterTest.enabled=true
### InjectModule configuration ###
# Mode of accessing properties
InjectModule.InjectIntoStatic.restore.default=old_value
InjectModule.InjectIntoByType.propertyAccess.default=field
InjectModule.InjectIntoStaticByType.restore.default=old_value
InjectModule.InjectIntoStaticByType.propertyAccess.default=field
InjectModule.TestedObject.createIfNull.enabled=true
### HibernateModule configuration ###
HibernateModule.configuration.implClassName=org.hibernate.cfg.AnnotationConfiguration
HibernateModule.currentsessioncontext.implClassName=org.unitils.hibernate.util.SimpleCurrentSessionContext
# Indicates whether after each test, all hibernate sessions that are still open need to be closed.
HibernateModule.autoCloseSessionsAfterTest.enabled=true
### SpringModule configuration ###
SpringModule.applicationContextFactory.implClassName=org.unitils.spring.util.ClassPathXmlApplicationContextFactory