• Home
• org.unitils
• unitils
• 1.0
• source code

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

nitils.1.0.source-code.unitils-default.properties Maven / Gradle / Ivy

####################################
# 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