public void DbCommandTimeoutConnectionTransactionSameNullParameters()
{
int commandTimeout = _faker.Random.Int();
string queryText = "Select * From Users";
CustomDbConnection connection = new CustomDbConnection()
{
ConnectionString = _connectionString
};
CustomDbTransaction transaction = connection.BeginTransaction() as CustomDbTransaction;
CommandType type = _faker.PickRandom <CommandType>();
DbCommand command = _factory.GetDbCommand(type, queryText, connection, null, commandTimeout, transaction);
Assert.IsNotNull(command);
Assert.IsNotNull(command.Parameters);
Assert.IsNotNull(command.Connection);
Assert.IsNotNull(command.Transaction);
Assert.IsNotNull(command.CommandText);
Assert.AreEqual(queryText, command.CommandText);
Assert.AreEqual(type, command.CommandType);
Assert.AreEqual(commandTimeout, command.CommandTimeout);
Assert.AreEqual(connection, command.Connection);
Assert.AreEqual(transaction, command.Transaction);
Assert.IsTrue(command.Parameters.Count == 0);
Assert.IsInstanceOf(typeof(CustomDbTransaction), command.Transaction);
Assert.IsInstanceOf(typeof(CustomDbConnection), command.Connection);
Assert.IsInstanceOf(typeof(CustomDbCommand), command);
Assert.IsInstanceOf(typeof(CustomDbParameterCollection), command.Parameters);
}
public void TestDbConnectionStatementBuilderForQuery()
{
// Prepare
var statementBuilder = new Mock <IStatementBuilder>();
var connection = new CustomDbConnection();
// Setup
statementBuilder.Setup(builder =>
builder.CreateQuery <DataEntity>(
It.IsAny <QueryBuilder <DataEntity> >(),
It.IsAny <QueryGroup>(),
It.IsAny <IEnumerable <OrderField> >(),
It.IsAny <int>(),
It.IsAny <string>()));
// Act
connection.Query <DataEntity>(e => e.Id == 1, statementBuilder: statementBuilder.Object);
// Assert
statementBuilder.Verify(builder =>
builder.CreateQuery <DataEntity>(
It.IsAny <QueryBuilder <DataEntity> >(),
It.IsAny <QueryGroup>(),
It.IsAny <IEnumerable <OrderField> >(),
It.IsAny <int>(),
It.IsAny <string>()), Times.Once);
}
public void TestSqlConnectionExecuteQueryViaDynamicsWithEmptyArrayParameters()
{
if (DbSettingMapper.Get(typeof(CustomDbConnection)) == null)
{
DbSettingMapper.Add(typeof(CustomDbConnection), new CustomDbSetting(), true);
}
using (var connection = new CustomDbConnection())
{
var sql = @"
select * from someTable
where id in (@normalArray)
and id in (@emptyArray)
and id in (@nullArray)
and id in (@concat1ArrayA, @concat1ArrayB)
and id in (@concat2ArrayA, @concat2ArrayB)
and id in (@concat3ArrayA, @concat3ArrayB)";
var param = new
{
normalArray = new[] { 5, 6 },
emptyArray = Array.Empty <int>(),
nullArray = (IEnumerable <int>)null,
concat1ArrayA = new[] { 100, 101 }, concat1ArrayB = new[] { 102, 103 },
concat2ArrayA = Array.Empty <int>(), concat2ArrayB = new[] { 200, 201 },
concat3ArrayA = Array.Empty <int>(), concat3ArrayB = Array.Empty <int>()
};
var command = connection.CreateDbCommandForExecution(sql, param, skipCommandArrayParametersCheck: false);
var expectedSql = @"
select * from someTable
where id in (@normalArray0, @normalArray1)
and id in ((SELECT @emptyArray WHERE 1 = 0))
and id in (@nullArray)
and id in (@concat1ArrayA0, @concat1ArrayA1, @concat1ArrayB0, @concat1ArrayB1)
and id in ((SELECT @concat2ArrayA WHERE 1 = 0), @concat2ArrayB0, @concat2ArrayB1)
and id in ((SELECT @concat3ArrayA WHERE 1 = 0), (SELECT @concat3ArrayB WHERE 1 = 0))";
Assert.AreEqual(expectedSql, command.CommandText);
Assert.AreEqual(13, command.Parameters.Count);
Assert.AreEqual(5, command.Parameters["@normalArray0"].Value);
Assert.AreEqual(6, command.Parameters["@normalArray1"].Value);
Assert.AreEqual(DBNull.Value, command.Parameters["@emptyArray"].Value);
Assert.AreEqual(DBNull.Value, command.Parameters["@nullArray"].Value);
Assert.AreEqual(100, command.Parameters["@concat1ArrayA0"].Value);
Assert.AreEqual(101, command.Parameters["@concat1ArrayA1"].Value);
Assert.AreEqual(102, command.Parameters["@concat1ArrayB0"].Value);
Assert.AreEqual(103, command.Parameters["@concat1ArrayB1"].Value);
Assert.AreEqual(DBNull.Value, command.Parameters["@concat2ArrayA"].Value);
Assert.AreEqual(200, command.Parameters["@concat2ArrayB0"].Value);
Assert.AreEqual(201, command.Parameters["@concat2ArrayB1"].Value);
Assert.AreEqual(DBNull.Value, command.Parameters["@concat3ArrayA"].Value);
Assert.AreEqual(DBNull.Value, command.Parameters["@concat3ArrayB"].Value);
}
}
public void DbCommandTimeoutConnectionTransactionParametersSame()
{
List <CustomDbParameter> parameters = new List <CustomDbParameter>()
{
new CustomDbParameter()
{
ParameterName = "@Param3"
},
new CustomDbParameter()
{
ParameterName = "@Param2"
},
new CustomDbParameter()
{
ParameterName = "@Param1"
}
};
int commandTimeout = _faker.Random.Int();
string queryText = "Select * From Users";
CustomDbConnection connection = new CustomDbConnection()
{
ConnectionString = _connectionString
};
CustomDbTransaction transaction = connection.BeginTransaction() as CustomDbTransaction;
CommandType type = _faker.PickRandom <CommandType>();
DbCommand command = _factory.GetDbCommand(type, queryText, connection, parameters, commandTimeout, transaction);
Assert.IsNotNull(command);
Assert.IsNotNull(command.Parameters);
Assert.IsNotNull(command.Connection);
Assert.IsNotNull(command.Transaction);
Assert.IsNotNull(command.CommandText);
Assert.AreEqual(queryText, command.CommandText);
Assert.AreEqual(type, command.CommandType);
Assert.AreEqual(commandTimeout, command.CommandTimeout);
Assert.AreEqual(connection, command.Connection);
Assert.AreEqual(transaction, command.Transaction);
Assert.IsTrue(parameters.Count == command.Parameters.Count);
Assert.IsInstanceOf(typeof(CustomDbTransaction), command.Transaction);
Assert.IsInstanceOf(typeof(CustomDbConnection), command.Connection);
Assert.IsInstanceOf(typeof(CustomDbCommand), command);
Assert.IsInstanceOf(typeof(CustomDbParameterCollection), command.Parameters);
//Assert all parameters are equal
for (int i = 0; i < command.Parameters.Count; i++)
{
DbParameter parameter = command.Parameters[i];
Assert.IsInstanceOf(typeof(CustomDbParameter), parameter);
Assert.AreEqual(parameters[i], parameter);
}
}
public void TestDbConnectionTraceForBeforeDelete()
{
// Prepare
var trace = new Mock <ITrace>();
var connection = new CustomDbConnection();
// Setup
trace.Setup(t => t.BeforeDelete(It.IsAny <CancellableTraceLog>()));
// Act
connection.Delete <TraceEntity>(0, trace: trace.Object, statementBuilder: new SqlStatementBuilder());
// Assert
trace.Verify(t => t.BeforeDelete(It.IsAny <CancellableTraceLog>()), Times.Once);
}
public void TestDbConnectionTraceForAfterCount()
{
// Prepare
var trace = new Mock <ITrace>();
var connection = new CustomDbConnection();
// Setup
trace.Setup(t => t.AfterCount(It.IsAny <TraceLog>()));
// Act
connection.Count <TraceEntity>(trace: trace.Object, statementBuilder: new SqlStatementBuilder());
// Assert
trace.Verify(t => t.AfterCount(It.IsAny <TraceLog>()), Times.Once);
}
public void TestDbConnectionTraceForAfterQueryMultiple()
{
// Prepare
var trace = new Mock <ITrace>();
var connection = new CustomDbConnection();
// Setup
trace.Setup(t => t.AfterQueryMultiple(It.IsAny <CancellableTraceLog>()));
// Act
connection.QueryMultiple <TraceEntity, TraceEntity>(te => te.Id == 1, te => te.Id == 1, trace: trace.Object, statementBuilder: new SqlStatementBuilder());
// Assert
trace.Verify(t => t.AfterQueryMultiple(It.IsAny <TraceLog>()), Times.Once);
}
public void TestDbConnectionTraceForAfterInlineMerge()
{
// Prepare
var trace = new Mock <ITrace>();
var connection = new CustomDbConnection();
// Setup
trace.Setup(t => t.AfterInlineMerge(It.IsAny <CancellableTraceLog>()));
// Act
connection.InlineMerge <TraceEntity>(new { Id = 1, Name = "Name" }, trace: trace.Object, statementBuilder: new SqlStatementBuilder());
// Assert
trace.Verify(t => t.AfterInlineMerge(It.IsAny <TraceLog>()), Times.Once);
}
public void DbCommandTimeoutConnectionSame()
{
int commandTimeout = _faker.Random.Int();
CustomDbConnection connection = new CustomDbConnection()
{
ConnectionString = _connectionString
};
DbCommand command = _factory.GetDbCommand(connection, commandTimeout);
Assert.IsNotNull(command);
Assert.AreEqual(commandTimeout, command.CommandTimeout);
Assert.AreEqual(connection, command.Connection);
Assert.IsInstanceOf(typeof(CustomDbConnection), command.Connection);
Assert.IsInstanceOf(typeof(CustomDbCommand), command);
}
public void TestDbConnectionQueryCacheKey()
{
// Prepare
var trace = new Mock <ITrace>();
var cache = new Mock <ICache>();
var connection = new CustomDbConnection();
// Setup
cache.Setup(c => c.Get(It.IsAny <string>(), It.IsAny <bool>()));
// Act
connection.Query <CacheEntity>(cacheKey: "MemoryCacheKey", cache: cache.Object, trace: trace.Object, statementBuilder: new SqlStatementBuilder());
// Assert
cache.Verify(c => c.Get(It.IsAny <string>(), It.IsAny <bool>()), Times.Once);
}
public void TestDbConnectionStatementBuilderForTruncate()
{
// Prepare
var statementBuilder = new Mock <IStatementBuilder>();
var connection = new CustomDbConnection();
// Setup
statementBuilder.Setup(builder =>
builder.CreateTruncate <DataEntity>(
It.IsAny <QueryBuilder <DataEntity> >()));
// Act
connection.Truncate <DataEntity>(statementBuilder: statementBuilder.Object);
// Assert
statementBuilder.Verify(builder =>
builder.CreateTruncate <DataEntity>(
It.IsAny <QueryBuilder <DataEntity> >()), Times.Once);
}
public void TestColumnAttributeUnquotedNameViaEntityViaCreateParameters()
{
// Act
using (var connection = new CustomDbConnection())
{
var command = connection.CreateCommand();
DbCommandExtension
.CreateParameters(command, new TestColumnAttributeUnquotedNameClass
{
Id = 1
});
// Assert
Assert.AreEqual(1, command.Parameters.Count);
// Assert
var parameter = command.Parameters["@PrimaryId"];
Assert.IsNotNull(parameter);
}
}
public void TestTypeMapAttributeUnquotedNameViaEntityViaCreateParameters()
{
// Act
using (var connection = new CustomDbConnection())
{
var command = connection.CreateCommand();
DbCommandExtension
.CreateParameters(command, new TestTypeMapAttributeUnquotedNameClass
{
ColumnString = "ColumnStringValue"
});
// Assert
Assert.AreEqual(1, command.Parameters.Count);
// Assert
var parameter = command.Parameters["@ColumnString"];
Assert.AreEqual(DbType.StringFixedLength, parameter.DbType);
}
}
public void TestDbConnectionStatementBuilderForInlineInsert()
{
// Prepare
var statementBuilder = new Mock <IStatementBuilder>();
var connection = new CustomDbConnection();
// Setup
statementBuilder.Setup(builder =>
builder.CreateInlineInsert <DataEntity>(
It.IsAny <QueryBuilder <DataEntity> >(),
It.IsAny <IEnumerable <Field> >()));
// Act
connection.InlineInsert <DataEntity>(new { Id = 1, Name = "Name" }, statementBuilder: statementBuilder.Object);
// Assert
statementBuilder.Verify(builder =>
builder.CreateInlineInsert <DataEntity>(
It.IsAny <QueryBuilder <DataEntity> >(),
It.IsAny <IEnumerable <Field> >()), Times.Once);
}
public void TestPropertyValueAttributeViaDerivedClassViaEntityViaCreateParameters()
{
// Act
using (var connection = new CustomDbConnection())
{
using (var command = connection.CreateCommand())
{
DbCommandExtension
.CreateParameters(command, new PropertyValueAttributeViaDerivedTestClass
{
ColumnName = "Test"
});
// Assert
Assert.AreEqual(1, command.Parameters.Count);
// Assert
var parameter = command.Parameters["@ColumnName"];
Assert.AreEqual("ValueOfTag", ((CustomDbParameter)parameter).Tag);
}
}
}
public void TestIsNullableAttributeViaEntityViaCreateParameters()
{
// Act
using (var connection = new CustomDbConnection())
{
using (var command = connection.CreateCommand())
{
DbCommandExtension
.CreateParameters(command, new IsNullableAttributeTestClass
{
ColumnName = "Test"
});
// Assert
Assert.AreEqual(1, command.Parameters.Count);
// Assert
var parameter = command.Parameters["@ColumnName"];
Assert.AreEqual(true, ((CustomDbParameter)parameter).IsNullable);
}
}
}
public void TestDbTypeAttributeViaEntityViaCreateParameters()
{
// Act
using (var connection = new CustomDbConnection())
{
using (var command = connection.CreateCommand())
{
DbCommandExtension
.CreateParameters(command, new DbTypeAttributeTestClass
{
ColumnName = "Test"
});
// Assert
Assert.AreEqual(1, command.Parameters.Count);
// Assert
var parameter = command.Parameters["@ColumnName"];
Assert.AreEqual(DbType.AnsiStringFixedLength, ((CustomDbParameter)parameter).DbType);
}
}
}
public void TestDirectionAttributeViaAnonymousViaCreateParameters()
{
// Act
using (var connection = new CustomDbConnection())
{
using (var command = connection.CreateCommand())
{
DbCommandExtension
.CreateParameters(command, new
{
ColumnName = "Test"
},
typeof(DirectionAttributeTestClass));
// Assert
Assert.AreEqual(1, command.Parameters.Count);
// Assert
var parameter = command.Parameters["@ColumnName"];
Assert.AreEqual(ParameterDirection.Output, ((CustomDbParameter)parameter).Direction);
}
}
}
public void TestDbConnectionStatementBuilderForUpdate()
{
// Prepare
var statementBuilder = new Mock <IStatementBuilder>();
var connection = new CustomDbConnection();
// Setup
statementBuilder.Setup(builder =>
builder.CreateUpdate <DataEntity>(
It.IsAny <QueryBuilder <DataEntity> >(),
It.IsAny <QueryGroup>()));
// Act
connection.Update <DataEntity>(new DataEntity {
Name = "Update"
}, e => e.Id == 1, statementBuilder: statementBuilder.Object);
// Assert
statementBuilder.Verify(builder =>
builder.CreateUpdate <DataEntity>(
It.IsAny <QueryBuilder <DataEntity> >(),
It.IsAny <QueryGroup>()), Times.Once);
}
public void TestDbConnectionStatementBuilderForMerge()
{
// Prepare
var statementBuilder = new Mock <IStatementBuilder>();
var connection = new CustomDbConnection();
// Setup
statementBuilder.Setup(builder =>
builder.CreateMerge <DataEntity>(
It.IsAny <QueryBuilder <DataEntity> >(),
It.IsAny <IEnumerable <Field> >()));
// Act
connection.Merge <DataEntity>(new DataEntity {
Name = "Name"
}, new Field(nameof(DataEntity.Id)), statementBuilder: statementBuilder.Object);
// Assert
statementBuilder.Verify(builder =>
builder.CreateMerge <DataEntity>(
It.IsAny <QueryBuilder <DataEntity> >(),
It.IsAny <IEnumerable <Field> >()), Times.Once);
}
public void TestDbConnectionStatementBuilderForQueryMultiple()
{
// Prepare
var statementBuilder = new Mock <IStatementBuilder>();
var connection = new CustomDbConnection();
// Setup
statementBuilder.Setup(builder =>
builder.CreateQuery <DataEntityT1>(
It.IsAny <QueryBuilder <DataEntityT1> >(),
It.IsAny <QueryGroup>(),
It.IsAny <IEnumerable <OrderField> >(),
It.IsAny <int>(),
It.IsAny <string>()));
statementBuilder.Setup(builder =>
builder.CreateQuery <DataEntityT2>(
It.IsAny <QueryBuilder <DataEntityT2> >(),
It.IsAny <QueryGroup>(),
It.IsAny <IEnumerable <OrderField> >(),
It.IsAny <int>(),
It.IsAny <string>()));
statementBuilder.Setup(builder =>
builder.CreateQuery <DataEntityT3>(
It.IsAny <QueryBuilder <DataEntityT3> >(),
It.IsAny <QueryGroup>(),
It.IsAny <IEnumerable <OrderField> >(),
It.IsAny <int>(),
It.IsAny <string>()));
statementBuilder.Setup(builder =>
builder.CreateQuery <DataEntityT4>(
It.IsAny <QueryBuilder <DataEntityT4> >(),
It.IsAny <QueryGroup>(),
It.IsAny <IEnumerable <OrderField> >(),
It.IsAny <int>(),
It.IsAny <string>()));
statementBuilder.Setup(builder =>
builder.CreateQuery <DataEntityT5>(
It.IsAny <QueryBuilder <DataEntityT5> >(),
It.IsAny <QueryGroup>(),
It.IsAny <IEnumerable <OrderField> >(),
It.IsAny <int>(),
It.IsAny <string>()));
statementBuilder.Setup(builder =>
builder.CreateQuery <DataEntityT6>(
It.IsAny <QueryBuilder <DataEntityT6> >(),
It.IsAny <QueryGroup>(),
It.IsAny <IEnumerable <OrderField> >(),
It.IsAny <int>(),
It.IsAny <string>()));
statementBuilder.Setup(builder =>
builder.CreateQuery <DataEntityT7>(
It.IsAny <QueryBuilder <DataEntityT7> >(),
It.IsAny <QueryGroup>(),
It.IsAny <IEnumerable <OrderField> >(),
It.IsAny <int>(),
It.IsAny <string>()));
// Act
connection.QueryMultiple <DataEntityT1,
DataEntityT2,
DataEntityT3,
DataEntityT4,
DataEntityT5,
DataEntityT6,
DataEntityT7>(e => e.Id == 1,
e => e.Id == 1,
e => e.Id == 1,
e => e.Id == 1,
e => e.Id == 1,
e => e.Id == 1,
e => e.Id == 1, statementBuilder: statementBuilder.Object);
// Assert
statementBuilder.Verify(builder =>
builder.CreateQuery <DataEntityT1>(
It.IsAny <QueryBuilder <DataEntityT1> >(),
It.IsAny <QueryGroup>(),
It.IsAny <IEnumerable <OrderField> >(),
It.IsAny <int>(),
It.IsAny <string>()), Times.Exactly(1));
statementBuilder.Verify(builder =>
builder.CreateQuery <DataEntityT2>(
It.IsAny <QueryBuilder <DataEntityT2> >(),
It.IsAny <QueryGroup>(),
It.IsAny <IEnumerable <OrderField> >(),
It.IsAny <int>(),
It.IsAny <string>()), Times.Exactly(1));
statementBuilder.Verify(builder =>
builder.CreateQuery <DataEntityT3>(
It.IsAny <QueryBuilder <DataEntityT3> >(),
It.IsAny <QueryGroup>(),
It.IsAny <IEnumerable <OrderField> >(),
It.IsAny <int>(),
It.IsAny <string>()), Times.Exactly(1));
statementBuilder.Verify(builder =>
builder.CreateQuery <DataEntityT4>(
It.IsAny <QueryBuilder <DataEntityT4> >(),
It.IsAny <QueryGroup>(),
It.IsAny <IEnumerable <OrderField> >(),
It.IsAny <int>(),
It.IsAny <string>()), Times.Exactly(1));
statementBuilder.Verify(builder =>
builder.CreateQuery <DataEntityT5>(
It.IsAny <QueryBuilder <DataEntityT5> >(),
It.IsAny <QueryGroup>(),
It.IsAny <IEnumerable <OrderField> >(),
It.IsAny <int>(),
It.IsAny <string>()), Times.Exactly(1));
statementBuilder.Verify(builder =>
builder.CreateQuery <DataEntityT6>(
It.IsAny <QueryBuilder <DataEntityT6> >(),
It.IsAny <QueryGroup>(),
It.IsAny <IEnumerable <OrderField> >(),
It.IsAny <int>(),
It.IsAny <string>()), Times.Exactly(1));
statementBuilder.Verify(builder =>
builder.CreateQuery <DataEntityT7>(
It.IsAny <QueryBuilder <DataEntityT7> >(),
It.IsAny <QueryGroup>(),
It.IsAny <IEnumerable <OrderField> >(),
It.IsAny <int>(),
It.IsAny <string>()), Times.Exactly(1));
}
