public void TestDbHelperForUpdateAllViaTableName()
{
// Prepare
var dbHelper = new Mock <IDbHelper>();
var connection = new CustomDbConnectionForDbHelper();
// Setup
dbHelper.Setup(builder =>
builder.GetFields(
It.Is <IDbConnection>(s => s == connection),
It.Is <string>(s => s == ClassMappedNameCache.Get <DataEntityForDbHelper>()),
It.IsAny <IDbTransaction>())
).Returns(GetDbFields());
// Act
CommandTextCache.Flush();
DbFieldCache.Flush();
StatementBuilderMapper.Add(typeof(CustomDbConnectionForDbHelper), new SqlServerStatementBuilder(), true);
DbHelperMapper.Add(typeof(CustomDbConnectionForDbHelper), dbHelper.Object, true);
// Act
connection.UpdateAll(ClassMappedNameCache.Get <DataEntityForDbHelper>(),
new[] { new DataEntityForDbHelper {
Id = 1, Name = "Name"
} });
// Assert
dbHelper.Verify(builder =>
builder.GetFields(
It.Is <IDbConnection>(s => s == connection),
It.Is <string>(s => s == ClassMappedNameCache.Get <DataEntityForDbHelper>()),
It.IsAny <IDbTransaction>()), Times.Exactly(1));
}
public void TestDbHelperForQueryViaTableName()
{
// Prepare
var dbHelper = new Mock <IDbHelper>();
var connection = new CustomDbConnectionForDbHelper();
// Setup
dbHelper.Setup(builder =>
builder.GetFields(
It.Is <string>(s => s == connection.ConnectionString),
It.Is <string>(s => s == ClassMappedNameCache.Get <DataEntityForDbHelper>()))
).Returns(GetDbFields());
// Act
CommandTextCache.Flush();
DbFieldCache.Flush();
StatementBuilderMapper.Add(typeof(CustomDbConnectionForDbHelper), new SqlStatementBuilder(), true);
DbHelperMapper.Add(typeof(CustomDbConnectionForDbHelper), dbHelper.Object, true);
// Act
connection.Query(ClassMappedNameCache.Get <DataEntityForDbHelper>(),
(object)null);
// Assert
dbHelper.Verify(builder =>
builder.GetFields(
It.Is <string>(s => s == connection.ConnectionString),
It.Is <string>(s => s == ClassMappedNameCache.Get <DataEntityForDbHelper>())), Times.Exactly(1));
}
public void TestDbHelperForBatchQuery()
{
// Prepare
var dbHelper = new Mock <IDbHelper>();
var connection = new CustomDbConnectionForDbHelper();
// Setup
dbHelper.Setup(builder =>
builder.GetFields(
It.Is <IDbConnection>(s => s == connection),
It.Is <string>(s => s == ClassMappedNameCache.Get <DataEntityForDbHelper>()),
It.IsAny <IDbTransaction>())
).Returns(GetDbFields());
// Act
CommandTextCache.Flush();
DbFieldCache.Flush();
StatementBuilderMapper.Add(typeof(CustomDbConnectionForDbHelper), new SqlServerStatementBuilder(), true);
DbHelperMapper.Add(typeof(CustomDbConnectionForDbHelper), dbHelper.Object, true);
// Act
connection.BatchQuery <DataEntityForDbHelper>(0,
10,
OrderField.Ascending <DataEntityForDbHelper>(e => e.Id).AsEnumerable(),
e => e.Id == 1);
// Assert
dbHelper.Verify(builder =>
builder.GetFields(
It.Is <IDbConnection>(s => s == connection),
It.Is <string>(s => s == ClassMappedNameCache.Get <DataEntityForDbHelper>()),
It.IsAny <IDbTransaction>()), Times.Exactly(1));
}
public void Init(string connectionString, DatabaseProvider databaseType)
{
DatabaseProvider = databaseType;
conn = DatabaseProvider.GetAndConfigureConnection(connectionString, (connection, dbType) =>
{
switch (dbType)
{
case DatabaseProvider.MySqlData:
MySqlBootstrap.Initialize();
break;
case DatabaseProvider.Npgsql:
PostgreSqlBootstrap.Initialize();
break;
case DatabaseProvider.SystemData:
{
var dbSetting = new SqlServerDbSetting();
DbSettingMapper.Add(typeof(System.Data.SqlClient.SqlConnection), dbSetting, true);
// Map the DbHelper
var dbHelper = new SqlServerDbHelper();
DbHelperMapper.Add(typeof(System.Data.SqlClient.SqlConnection), dbHelper, true);
// Map the Statement Builder
var statementBuilder = new SqlServerStatementBuilder(dbSetting);
StatementBuilderMapper.Add(typeof(System.Data.SqlClient.SqlConnection), statementBuilder, true);
break;
}
case DatabaseProvider.MicrosoftData:
{
var dbSetting = new SqlServerDbSetting();
DbSettingMapper.Add(typeof(Microsoft.Data.SqlClient.SqlConnection), dbSetting, true);
// Map the DbHelper
var dbHelper = new SqlServerDbHelper();
DbHelperMapper.Add(typeof(Microsoft.Data.SqlClient.SqlConnection), dbHelper, true);
// Map the Statement Builder
var statementBuilder = new SqlServerStatementBuilder(dbSetting);
StatementBuilderMapper.Add(typeof(Microsoft.Data.SqlClient.SqlConnection), statementBuilder, true);
break;
}
case DatabaseProvider.MySqlConnector:
MySqlConnectorBootstrap.Initialize();
break;
default:
throw new ArgumentOutOfRangeException();
}
connection.Open();
return(connection);
});
}
public void Initialize()
{
// For Non-Attributed Entity
DbSettingMapper.Add(typeof(ClassHandlerConnection), new CustomDbSetting(), true);
DbHelperMapper.Add(typeof(ClassHandlerConnection), new CustomDbHelper(), true);
StatementBuilderMapper.Add(typeof(ClassHandlerConnection), new CustomStatementBuilder(), true);
// For Attributed Entity
DbSettingMapper.Add(typeof(ClassHandlerForEntityWithAttributeConnection), new CustomDbSetting(), true);
DbHelperMapper.Add(typeof(ClassHandlerForEntityWithAttributeConnection), new CustomDbHelper(), true);
StatementBuilderMapper.Add(typeof(ClassHandlerForEntityWithAttributeConnection), new CustomStatementBuilder(), true);
}
public void TestStatementBuilderMapperMappingViaGeneric()
{
// Setup
var statementBuilder = new CustomStatementBuilder();
StatementBuilderMapper.Add <CustomDbConnection>(statementBuilder, true);
// Act
var actual = StatementBuilderMapper.Get <CustomDbConnection>();
// Assert
Assert.AreSame(statementBuilder, actual);
}
public static void Initialize()
{
// Map the DbHelper
DbHelperMapper.Add(typeof(SQLiteConnection), new SqLiteDbHelper(), true);
// Map the DbValidator
DbValidatorMapper.Add(typeof(SQLiteConnection), new SqLiteDbValidator(), true);
// Map the Statement Builder
StatementBuilderMapper.Add(typeof(SQLiteConnection), new SqLiteStatementBuilder(), true);
// Map the Setting
}
public static void Initialize()
{
if (IsInitialized)
{
return;
}
// Map the DbSetting
var dbSetting = new DB2iSeriesDbSettings();
DbSettingMapper.Add(typeof(iDB2Connection), dbSetting, true);
DbHelperMapper.Add(typeof(iDB2Connection), new DB2iSeriesDbHelper <iDB2Connection>(), true);
StatementBuilderMapper.Add(typeof(iDB2Connection), new DB2iSeries_SqlServerStatementBuilder <iDB2Connection>(dbSetting), true);
// Set the flag
IsInitialized = true;
}
public void TestStatementBuilderMapperMappingCanBeRemovedViaGeneric()
{
// Setup
var statementBuilder = new CustomStatementBuilder();
StatementBuilderMapper.Add <CustomDbConnection>(statementBuilder, true);
// Act
StatementBuilderMapper.Remove <CustomDbConnection>();
// Assert
var actual = StatementBuilderMapper.Get <CustomDbConnection>();
Assert.IsNull(actual);
}
/// <summary>
/// Initializes all necessary settings for PostgreSql.
/// </summary>
public static void Initialize()
{
// Skip if already initialized
if (Initialized == true)
{
return;
}
// Map the DbSetting
DbSettingMapper.Add(typeof(NpgsqlConnection), new PostgreSqlDbSetting(), true);
// Map the DbHelper
DbHelperMapper.Add(typeof(NpgsqlConnection), new PostgreSqlDbHelper(), true);
// Map the Statement Builder
StatementBuilderMapper.Add(typeof(NpgsqlConnection), new PostgreSqlStatementBuilder(), true);
// Set the flag
Initialized = true;
}
private void Setup(IDbSetting settings)
{
if (_isInitialized)
{
return;
}
lock (_mutex)
{
DbSettingMapper.Add(typeof(SQLiteConnection), settings, true);
// Map the DbHelper
DbHelperMapper.Add(typeof(SQLiteConnection), new SqLiteDbHelper(settings, new SdsSqLiteDbTypeNameToClientTypeResolver()), true);
// Map the Statement Builder
StatementBuilderMapper.Add(typeof(SQLiteConnection), new SqLiteStatementBuilder(settings), true);
// Set the flag
_isInitialized = true;
}
}
public void TestDbHelperForQueryAll()
{
// Prepare
var dbHelper = new Mock <IDbHelper>();
var connection = new CustomDbConnectionForDbHelper();
// Act
CommandTextCache.Flush();
DbFieldCache.Flush();
StatementBuilderMapper.Add(typeof(CustomDbConnectionForDbHelper), new SqlServerStatementBuilder(), true);
DbHelperMapper.Add(typeof(CustomDbConnectionForDbHelper), dbHelper.Object, true);
// Act
connection.QueryAll <DataEntityForDbHelper>();
// Assert
dbHelper.Verify(builder =>
builder.GetFields(
It.Is <IDbConnection>(s => s == connection),
It.Is <string>(s => s == ClassMappedNameCache.Get <DataEntityForDbHelper>()),
It.IsAny <IDbTransaction>()), Times.Exactly(1));
}
public void TestDbHelperForInsert()
{
// Prepare
var dbHelper = new Mock <IDbHelper>();
var connection = new CustomDbConnectionForDbHelper();
// Act
CommandTextCache.Flush();
DbFieldCache.Flush();
StatementBuilderMapper.Add(typeof(CustomDbConnectionForDbHelper), new SqlStatementBuilder(), true);
DbHelperMapper.Add(typeof(CustomDbConnectionForDbHelper), dbHelper.Object, true);
// Act
connection.Insert <DataEntityForDbHelper>(new DataEntityForDbHelper {
Id = 1, Name = "Name"
});
// Assert
dbHelper.Verify(builder =>
builder.GetFields(
It.Is <string>(s => s == connection.ConnectionString),
It.Is <string>(s => s == ClassMappedNameCache.Get <DataEntityForDbHelper>())), Times.Exactly(1));
}
public void Initialize()
{
StatementBuilderMapper.Add <BaseStatementBuilderDbConnection>(new CustomBaseStatementBuilder(), true);
}
public void Initialize()
{
DbSettingMapper.Add(typeof(CacheDbConnection), new CustomDbSetting(), true);
StatementBuilderMapper.Add(typeof(CacheDbConnection), new CustomStatementBuilder(), true);
}
public void Initialize()
{
DbSettingMapper.Add <CacheDbConnection>(new CustomDbSetting(), true);
DbHelperMapper.Add <CacheDbConnection>(new CustomDbHelper(), true);
StatementBuilderMapper.Add <CacheDbConnection>(new CustomStatementBuilder(), true);
}
public void Initialize()
{
StatementBuilderMapper.Add <BaseStatementBuilderDbConnection>(new CustomBaseStatementBuilder(), true);
StatementBuilderMapper.Add <NonHintsSupportingBaseStatementBuilderDbConnection>(new CustomNonHintsSupportingBaseStatementBuilder(), true);
}
public void Initialize()
{
StatementBuilderMapper.Add(typeof(BaseStatementBuilderDbConnection), new CustomBaseStatementBuilder(), true);
StatementBuilderMapper.Add(typeof(DefinedBaseStatementBuilderDbConnection), new CustomDefinedBaseStatementBuilder(), true);
StatementBuilderMapper.Add(typeof(NonHintsSupportingBaseStatementBuilderDbConnection), new CustomNonHintsSupportingBaseStatementBuilder(), true);
}
public void Initialize()
{
StatementBuilderMapper.Add(typeof(BaseStatementBuilderDbConnection), new CustomBaseStatementBuilder(), true);
}
public void Initialize()
{
DbSettingMapper.Add(typeof(PropertyHandlerConnection), new CustomDbSetting(), true);
DbHelperMapper.Add(typeof(PropertyHandlerConnection), new CustomDbHelper(), true);
StatementBuilderMapper.Add(typeof(PropertyHandlerConnection), new CustomStatementBuilder(), true);
}
public static void ClassInitialize(TestContext context)
{
DbSettingMapper.Add(typeof(TraceDbConnection), new CustomDbSetting(), true);
DbHelperMapper.Add(typeof(TraceDbConnection), new CustomDbHelper(), true);
StatementBuilderMapper.Add(typeof(TraceDbConnection), new CustomStatementBuilder(), true);
}