public void TestProfiledDataReaderWrapper_Equals()
{
var mockReader = new Mock<IDataReader>();
var mockDbProfiler = new Mock<IDbProfiler>();
var target = new ProfiledDbDataReader(mockReader.Object, mockDbProfiler.Object);
Assert.IsTrue(target.Equals(target));
Assert.IsTrue(target.Equals(mockReader.Object));
Assert.AreEqual(target.GetHashCode(), mockReader.Object.GetHashCode());
Assert.IsFalse(target.Equals(null));
Assert.IsTrue(target == target);
Assert.IsFalse(target == (ProfiledDbDataReader)null);
Assert.IsFalse((ProfiledDbDataReader)null == target);
Assert.IsFalse(target == (IDataReader)null);
Assert.IsFalse((IDataReader)null == target);
Assert.IsTrue(target == mockReader.Object);
Assert.IsTrue(mockReader.Object == target);
Assert.IsFalse(target != target);
Assert.IsFalse(target != mockReader.Object);
Assert.IsFalse(mockReader.Object != target);
Assert.IsTrue(target != (ProfiledDbDataReader)null);
Assert.IsTrue((ProfiledDbDataReader)null != target);
Assert.IsTrue(target != (IDataReader)null);
Assert.IsTrue((IDataReader)null != target);
var target2 = new ProfiledDbDataReader(mockReader.Object, mockDbProfiler.Object);
Assert.IsTrue(target.Equals(target2));
Assert.IsTrue(target == target2);
Assert.IsFalse(target != target2);
var mockReader2 = new Mock<IDataReader>();
var target3 = new ProfiledDbDataReader(mockReader2.Object, mockDbProfiler.Object);
Assert.IsFalse(target == target3);
Assert.IsTrue(target != target3);
}
public void TestProfiledDataReaderWrapper()
{
var mockSqlProfiler = new Mock<IDbProfiler>();
bool closed = false;
bool readerFinished = false;
int depth = 2;
int fieldCount = 3;
int ordinal = 4;
bool boolValue = true;
byte byteValue = 5;
long dataOffset = 6;
byte[] bytesBuffer = new byte[1];
int bufferOffset = 7;
int length = 8;
long bytesValue = 9;
char charValue = (char)10;
long charsValue = 11;
char[] charsBuffer = new char[1];
string dataTypeName = "test";
DateTime dateTimeValue = DateTime.Now;
decimal decimalValue = 12;
double doubleValue = 13;
Type fieldType = typeof(string);
float floatValue = 14;
Guid guidValue = Guid.NewGuid();
short int16Value = 15;
int int32Value = 16;
long int64Value = 17;
string name = "test";
DataTable dataTable = new DataTable();
string stringValue = "test";
object value = new object();
object[] values = new object[1];
int valuesValue = 18;
bool isClosed = true;
bool isDBNull = true;
bool nextResult = true;
bool readValue = true;
int recordsAffected = 20;
object thisByName = new object();
object thisByOrdinal = new object();
bool hasRows = true;
var mockReader1 = new Mock<IDataReader>();
mockReader1.Setup(reader => reader.Close()).Callback(() => closed = true);
mockReader1.Setup(reader => reader.Depth).Returns(depth);
mockReader1.Setup(reader => reader.FieldCount).Returns(fieldCount);
mockReader1.Setup(reader => reader.GetBoolean(ordinal)).Returns(boolValue);
mockReader1.Setup(reader => reader.GetByte(ordinal)).Returns(byteValue);
mockReader1.Setup(reader => reader.GetBytes(ordinal, dataOffset, bytesBuffer, bufferOffset, length)).Returns(bytesValue);
mockReader1.Setup(reader => reader.GetChar(ordinal)).Returns(charValue);
mockReader1.Setup(reader => reader.GetChars(ordinal, dataOffset, charsBuffer, bufferOffset, length)).Returns(charsValue);
mockReader1.Setup(reader => reader.GetDataTypeName(ordinal)).Returns(dataTypeName);
mockReader1.Setup(reader => reader.GetDateTime(ordinal)).Returns(dateTimeValue);
mockReader1.Setup(reader => reader.GetDecimal(ordinal)).Returns(decimalValue);
mockReader1.Setup(reader => reader.GetDouble(ordinal)).Returns(doubleValue);
mockReader1.Setup(reader => reader.GetFieldType(ordinal)).Returns(fieldType);
mockReader1.Setup(reader => reader.GetFloat(ordinal)).Returns(floatValue);
mockReader1.Setup(reader => reader.GetGuid(ordinal)).Returns(guidValue);
mockReader1.Setup(reader => reader.GetInt16(ordinal)).Returns(int16Value);
mockReader1.Setup(reader => reader.GetInt32(ordinal)).Returns(int32Value);
mockReader1.Setup(reader => reader.GetInt64(ordinal)).Returns(int64Value);
mockReader1.Setup(reader => reader.GetName(ordinal)).Returns(name);
mockReader1.Setup(reader => reader.GetOrdinal(name)).Returns(ordinal);
mockReader1.Setup(reader => reader.GetSchemaTable()).Returns(dataTable);
mockReader1.Setup(reader => reader.GetString(ordinal)).Returns(stringValue);
mockReader1.Setup(reader => reader.GetValue(ordinal)).Returns(value);
mockReader1.Setup(reader => reader.GetValues(values)).Returns(valuesValue);
mockReader1.Setup(reader => reader.IsClosed).Returns(isClosed);
mockReader1.Setup(reader => reader.IsDBNull(ordinal)).Returns(isDBNull);
mockReader1.Setup(reader => reader.NextResult()).Returns(nextResult);
mockReader1.Setup(reader => reader.Read()).Returns(readValue);
mockReader1.Setup(reader => reader.RecordsAffected).Returns(recordsAffected);
mockReader1.Setup(reader => reader[name]).Returns(thisByName);
mockReader1.Setup(reader => reader[ordinal]).Returns(thisByOrdinal);
var mockReader2 = new Mock<DbDataReader>();
var dataRecordEnumerator = new IDataRecord[0].GetEnumerator();
mockReader2.Setup(reader => reader.GetEnumerator()).Returns(dataRecordEnumerator);
mockReader2.Setup(reader => reader.HasRows).Returns(hasRows);
var target1 = new ProfiledDbDataReader(mockReader1.Object, mockSqlProfiler.Object);
var target2 = new ProfiledDbDataReader(mockReader2.Object, mockSqlProfiler.Object);
mockSqlProfiler.Setup(sqlProfiler => sqlProfiler.DataReaderFinished(It.IsAny<IDataReader>()))
.Callback<IDataReader>(a =>
{
Assert.AreEqual(target1, a);
readerFinished = true;
});
// Close()
closed = false;
readerFinished = false;
target1.Close();
Assert.IsTrue(closed);
Assert.IsTrue(readerFinished);
Assert.AreEqual(depth, target1.Depth);
Assert.AreEqual(fieldCount, target1.FieldCount);
Assert.AreEqual(boolValue, target1.GetBoolean(ordinal));
Assert.AreEqual(byteValue, target1.GetByte(ordinal));
Assert.AreEqual(bytesValue, target1.GetBytes(ordinal, dataOffset, bytesBuffer, bufferOffset, length));
Assert.AreEqual(charValue, target1.GetChar(ordinal));
Assert.AreEqual(charsValue, target1.GetChars(ordinal, dataOffset, charsBuffer, bufferOffset, length));
Assert.AreEqual(dataTypeName, target1.GetDataTypeName(ordinal));
Assert.AreEqual(dateTimeValue, target1.GetDateTime(ordinal));
Assert.AreEqual(decimalValue, target1.GetDecimal(ordinal));
Assert.AreEqual(doubleValue, target1.GetDouble(ordinal));
Assert.AreEqual(fieldType, target1.GetFieldType(ordinal));
Assert.AreEqual(floatValue, target1.GetFloat(ordinal));
Assert.AreEqual(guidValue, target1.GetGuid(ordinal));
Assert.AreEqual(int16Value, target1.GetInt16(ordinal));
Assert.AreEqual(int32Value, target1.GetInt32(ordinal));
Assert.AreEqual(int64Value, target1.GetInt64(ordinal));
Assert.AreEqual(name, target1.GetName(ordinal));
Assert.AreEqual(ordinal, target1.GetOrdinal(name));
Assert.AreEqual(dataTable, target1.GetSchemaTable());
Assert.AreEqual(stringValue, target1.GetString(ordinal));
Assert.AreEqual(value, target1.GetValue(ordinal));
Assert.AreEqual(valuesValue, target1.GetValues(values));
Assert.AreEqual(isClosed, target1.IsClosed);
Assert.AreEqual(isDBNull, target1.IsDBNull(ordinal));
Assert.AreEqual(nextResult, target1.NextResult());
Assert.AreEqual(readValue, target1.Read());
Assert.AreEqual(recordsAffected, target1.RecordsAffected);
Assert.AreEqual(thisByName, target1[name]);
Assert.AreEqual(thisByOrdinal, target1[ordinal]);
// GetEnumerator
Assert.AreEqual(typeof(DbEnumerator), target1.GetEnumerator().GetType());
Assert.AreEqual(dataRecordEnumerator, target2.GetEnumerator());
// HasRows
Assert.IsTrue(target1.HasRows);
Assert.IsTrue(target2.HasRows);
}
public void TestProfiledDbCommandWithProfiledDbCommand()
{
var mockCommand = new Mock<DbCommand>();
var mockDbProfiler = new Mock<IDbProfiler>();
var target = new ProfiledDbCommand(mockCommand.Object, mockDbProfiler.Object);
// test CreateDbParameter()
var mockParameter = new Mock<DbParameter>();
mockCommand.Protected().Setup<DbParameter>("CreateDbParameter").Returns(mockParameter.Object);
Assert.AreEqual(mockParameter.Object, target.CreateParameter());
// test DbConnection
var mockConnection = new Mock<DbConnection>();
var profiledConnection = new ProfiledDbConnection(mockConnection.Object, mockDbProfiler.Object);
mockCommand.Protected().Setup<DbConnection>("DbConnection").Returns(profiledConnection);
var connection = target.Connection;
Assert.AreEqual(profiledConnection, connection);
// test DbParameterCollection
var mockParameterCollection = new Mock<DbParameterCollection>();
mockCommand.Protected().Setup<DbParameterCollection>("DbParameterCollection").Returns(mockParameterCollection.Object);
var parameterCollection = target.Parameters;
Assert.AreEqual(mockParameterCollection.Object, parameterCollection);
// test DbTransaction
var mockTransaction = new Mock<DbTransaction>();
var profiledTransaction = new ProfiledDbTransaction(mockTransaction.Object, mockDbProfiler.Object);
mockCommand.Protected().Setup<DbTransaction>("DbTransaction").Returns(profiledTransaction);
var transaction = target.Transaction;
Assert.AreEqual(profiledTransaction, transaction);
// test DesignTimeVisible
var designTimeVisible1 = true;
var designTimeVisible2 = false;
var designTimeVisibleSet = false;
mockCommand.Setup(cmd => cmd.DesignTimeVisible).Returns(designTimeVisible1);
mockCommand.SetupSet(cmd => cmd.DesignTimeVisible = It.IsAny<bool>()).Callback<bool>(a =>
{
Assert.AreEqual(designTimeVisible2, a);
designTimeVisibleSet = true;
});
Assert.AreEqual(designTimeVisible1, target.DesignTimeVisible);
target.DesignTimeVisible = designTimeVisible2;
Assert.IsTrue(designTimeVisibleSet);
// test ExecuteDbDataReader()
var mockReader = new Mock<DbDataReader>();
var profiledReader = new ProfiledDbDataReader(mockReader.Object, mockDbProfiler.Object);
var cmdBehavior = CommandBehavior.CloseConnection;
mockCommand.Protected().Setup<DbDataReader>("ExecuteDbDataReader", cmdBehavior).Returns(profiledReader);
var executeDbCommandCalled = false;
mockDbProfiler.Setup(p => p.ExecuteDbCommand(It.IsAny<DbExecuteType>(), It.IsAny<IDbCommand>(), It.IsAny<Func<IDataReader>>(), It.IsAny<IEnumerable<string>>()))
.Callback<DbExecuteType, IDbCommand, Func<IDataReader>, IEnumerable<string>>((a, b, c, d) =>
{
Assert.AreEqual(mockCommand.Object, b);
c();
executeDbCommandCalled = true;
});
var reader = target.ExecuteReader(cmdBehavior);
Assert.IsTrue(executeDbCommandCalled);
Assert.AreEqual(profiledReader, reader);
// test Dispose()
var disposeCalled = false;
mockCommand.Protected().Setup("Dispose", true).Callback<bool>(a => disposeCalled = true);
target.Dispose();
Assert.IsTrue(disposeCalled);
}
