/// <summary>
/// Functionality which can handle a query for getting some data for a household member.
/// </summary>
/// <param name="query">Query for getting some data for a household member.</param>
/// <returns>View of the selected data.</returns>
public virtual TView Query(TQuery query)
{
ArgumentNullGuard.NotNull(query, nameof(query));
ITranslationInfo translationInfo = GetTranslationInfo(query);
IHouseholdMember householdMember = HouseholdDataRepository.HouseholdMemberGetByMailAddress(ClaimValueProvider.MailAddress);
if (householdMember == null)
{
throw new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.HouseholdMemberNotCreated));
}
if (ShouldBeActivated && householdMember.IsActivated == false)
{
throw new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.HouseholdMemberNotActivated));
}
if (ShouldHaveAcceptedPrivacyPolicy && householdMember.IsPrivacyPolicyAccepted == false)
{
throw new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.HouseholdMemberHasNotAcceptedPrivacyPolicy));
}
if (householdMember.HasRequiredMembership(RequiredMembership) == false)
{
throw new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.HouseholdMemberHasNotRequiredMembership));
}
TData data = GetData(householdMember, query, translationInfo);
return(ObjectMapper.Map <TData, TView>(data, translationInfo?.CultureInfo));
}
/// <summary>
/// Gets the household identifier from the data reader.
/// </summary>
/// <param name="dataReader">The data reader from which to read.</param>
/// <param name="columnName">The column name for value to read.</param>
/// <returns>The household identifier.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="dataReader"/> is null or <paramref name="columnName"/> is null, empty or white space.</exception>
private static Guid GetHouseholdIdentifier(MySqlDataReader dataReader, string columnName)
{
ArgumentNullGuard.NotNull(dataReader, nameof(dataReader))
.NotNullOrWhiteSpace(columnName, nameof(columnName));
return(new Guid(dataReader.GetString(columnName)));
}
/// <summary>
/// Gets the time for when the household was created from the data reader.
/// </summary>
/// <param name="dataReader">The data reader from which to read.</param>
/// <param name="columnName">The column name for value to read.</param>
/// <returns>The time for when the household was created.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="dataReader"/> is null or <paramref name="columnName"/> is null, empty or white space.</exception>
private static DateTime GetCreationTime(MySqlDataReader dataReader, string columnName)
{
ArgumentNullGuard.NotNull(dataReader, nameof(dataReader))
.NotNullOrWhiteSpace(columnName, nameof(columnName));
return(dataReader.GetMySqlDateTime(columnName).Value.ToLocalTime());
}
/// <summary>
/// Danner en data provider, som benytter MySql.
/// </summary>
/// <param name="mySqlConnection">Eksisterende MySql connection.</param>
/// <param name="clonedWithReusableConnection">True, ved en genbrugelig conntion ellers false.</param>
/// <exception cref="System.ArgumentNullException">Thrown when <paramref name="mySqlConnection"/> is null.</exception>
protected MySqlDataProvider(MySqlConnection mySqlConnection, bool clonedWithReusableConnection)
{
ArgumentNullGuard.NotNull(mySqlConnection, nameof(mySqlConnection));
_mySqlConnection = mySqlConnection;
_clonedWithReusableConnection = clonedWithReusableConnection;
}
/// <summary>
/// Gets the temperature from the data reader.
/// </summary>
/// <param name="dataReader">The data reader from which to read.</param>
/// <param name="columnName">The column name for value to read.</param>
/// <returns>The temperature.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="dataReader"/> is null or <paramref name="columnName"/> is null, empty or white space.</exception>
private static int GetTemperature(MySqlDataReader dataReader, string columnName)
{
ArgumentNullGuard.NotNull(dataReader, nameof(dataReader))
.NotNullOrWhiteSpace(columnName, nameof(columnName));
return(dataReader.GetInt16(columnName));
}
/// <summary>
/// Adds a payment reference parameter to the command.
/// </summary>
/// <param name="value">The value for the payment reference.</param>
/// <returns>This instance of the <see cref="HouseholdDataCommandBuilder"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="value"/> is null, empty or white space.</exception>
internal HouseholdDataCommandBuilder AddPaymentReferenceParameter(string value)
{
ArgumentNullGuard.NotNullOrWhiteSpace(value, nameof(value));
AddVarCharParameter("@paymentReference", value, 128);
return(this);
}
/// <summary>
/// Henter og returnerer data fra MySql.
/// </summary>
/// <typeparam name="TDataProxy">Typen på data proxy med data fra MySql.</typeparam>
/// <param name="queryCommand">Database command for the SQL query statement.</param>
/// <returns>Collection indeholdende data proxies.</returns>
/// <exception cref="System.ArgumentNullException">Thrown when the <paramref name="queryCommand"/> is null.</exception>
public override IEnumerable <TDataProxy> GetCollection <TDataProxy>(MySqlCommand queryCommand)
{
ArgumentNullGuard.NotNull(queryCommand, nameof(queryCommand));
Open();
try
{
List <TDataProxy> collection = new List <TDataProxy>();
using (MySqlCommand command = queryCommand)
{
command.Connection = _mySqlConnection;
using (MySqlDataReader reader = command.ExecuteReader())
{
if (reader.HasRows == false)
{
reader.Close();
return(collection);
}
while (reader.Read())
{
TDataProxy dataProxy = new TDataProxy();
dataProxy.MapData(reader, this);
collection.Add(dataProxy);
}
reader.Close();
}
}
collection.ForEach(proxy => proxy.MapRelations(this));
return(collection);
}
finally
{
Close();
}
}
/// <summary>
/// Adds a translation value parameter to the command.
/// </summary>
/// <param name="value">The value for the translation value.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="value"/> is null, empty or white space.</exception>
internal SystemDataCommandBuilder AddTranslationValueParameter(string value)
{
ArgumentNullGuard.NotNullOrWhiteSpace(value, nameof(value));
AddVarCharParameter("@value", value, 4096);
return(this);
}
/// <summary>
/// Maps data from the data reader.
/// </summary>
/// <param name="dataReader">Data reader.</param>
/// <param name="dataProvider">Implementation of the data provider used to access data.</param>
public virtual void MapData(MySqlDataReader dataReader, IDataProviderBase <MySqlDataReader, MySqlCommand> dataProvider)
{
ArgumentNullGuard.NotNull(dataReader, nameof(dataReader))
.NotNull(dataProvider, nameof(dataProvider));
Identifier = new Guid(dataReader.GetString("ForeignKeyIdentifier"));
DataProvider = dataProvider.Create(new DataProviderProxy(), dataReader, "DataProviderIdentifier", "DataProviderName", "HandlesPayments", "DataSourceStatementIdentifier");
ForeignKeyForIdentifier = new Guid(dataReader.GetString("ForeignKeyForIdentifier"));
ForeignKeyValue = dataReader.GetString("ForeignKeyValue");
IList <Type> foreignKeyForTypes = new List <Type>();
foreach (var foreignKeyForTypeName in dataReader.GetString("ForeignKeyForTypes").Split(';').Where(m => string.IsNullOrWhiteSpace(m) == false))
{
// ReSharper disable EmptyGeneralCatchClause
try
{
var typeName = foreignKeyForTypeName;
var assembly = typeof(IDomainObject).Assembly;
var type = assembly.GetTypes().SingleOrDefault(m => string.Compare(m.Name, typeName, StringComparison.Ordinal) == 0);
if (type != null)
{
foreignKeyForTypes.Add(type);
}
}
catch
{
// Don't throw the exception. Just ignore the type.
}
// ReSharper restore EmptyGeneralCatchClause
}
ForeignKeyForTypes = foreignKeyForTypes;
// DataProviderIdentifier = new Guid(dataReader.GetString("DataProviderIdentifier"));
}
/// <summary>
/// Adds a foreign key value parameter to the command.
/// </summary>
/// <param name="value">The value for the foreign key value.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="value"/> is null, empty or white space.</exception>
internal SystemDataCommandBuilder AddForeignKeyValueParameter(string value)
{
ArgumentNullGuard.NotNullOrWhiteSpace(value, nameof(value));
AddVarCharParameter("@foreignKeyValue", value, 128);
return(this);
}
/// <summary>
/// Adds a data provider name parameter to the command.
/// </summary>
/// <param name="value">The value for the data provider name.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="value"/> is null, empty or white space.</exception>
internal SystemDataCommandBuilder AddDataProviderNameParameter(string value)
{
ArgumentNullGuard.NotNullOrWhiteSpace(value, nameof(value));
AddVarCharParameter("@name", value, 256);
return(this);
}
/// <summary>
/// Adds a foreign key for types like parameter to the command.
/// </summary>
/// <param name="value">The value for the foreign key for types.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="value"/> is null.</exception>
internal SystemDataCommandBuilder AddForeignKeyForTypesLikeParameter(Type value)
{
ArgumentNullGuard.NotNull(value, nameof(value));
AddVarCharParameter("@foreignKeyForTypes", $"%{value.Name}%", 128);
return(this);
}
/// <summary>
/// Adds a foreign key for types parameter to the command.
/// </summary>
/// <param name="value">The value for the foreign key for types.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="value"/> is null.</exception>
internal SystemDataCommandBuilder AddForeignKeyForTypesParameter(IEnumerable <Type> value)
{
ArgumentNullGuard.NotNull(value, nameof(value));
AddVarCharParameter("@foreignKeyForTypes", string.Join(";", value.Select(m => m.Name)), 128);
return(this);
}
/// <summary>
/// Gets the membership from the data reader.
/// </summary>
/// <param name="dataReader">The data reader from which to read.</param>
/// <param name="columnName">The column name for value to read.</param>
/// <returns>The membership.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="dataReader"/> is null or <paramref name="columnName"/> is null, empty or white space.</exception>
private static Membership GetMembership(MySqlDataReader dataReader, string columnName)
{
ArgumentNullGuard.NotNull(dataReader, nameof(dataReader))
.NotNullOrWhiteSpace(columnName, nameof(columnName));
return((Membership)dataReader.GetInt16(columnName));
}
/// <summary>
/// Gets the appointment note from the data reader.
/// </summary>
/// <param name="dataReader">The data reader.</param>
/// <param name="columnName">Column name.</param>
/// <returns>Appointment note.</returns>
private static string GetAppointmentNote(MySqlDataReader dataReader, string columnName)
{
ArgumentNullGuard.NotNull(dataReader, nameof(dataReader))
.NotNullOrWhiteSpace(columnName, nameof(columnName));
return(dataReader.IsDBNull(dataReader.GetOrdinal(columnName)) ? null : dataReader.GetString(columnName));
}
/// <summary>
/// Deletes the bindings which bind a given household to all the household members who has membership.
/// </summary>
/// <param name="dataProvider">Implementation of the data provider used to access data.</param>
/// <param name="householdProxy">Data proxy for the household on which to delete the bindings.</param>
/// <returns>Affected household members.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="dataProvider"/> or <paramref name="householdProxy"/> is null.</exception>
internal static IEnumerable <IHouseholdMemberProxy> DeleteMemberOfHouseholds(IDataProviderBase <MySqlDataReader, MySqlCommand> dataProvider, IHouseholdProxy householdProxy)
{
ArgumentNullGuard.NotNull(dataProvider, nameof(dataProvider))
.NotNull(householdProxy, nameof(householdProxy));
return(DeleteMemberOfHouseholds(dataProvider, () => GetMemberOfHouseholds(dataProvider, householdProxy).ToArray(), memberOfHouseholdProxy => memberOfHouseholdProxy.HouseholdMember as IHouseholdMemberProxy));
}
/// <summary>
/// Adds a mail address parameter to the command.
/// </summary>
/// <param name="value">The value for the mail address.</param>
/// <returns>This instance of the <see cref="HouseholdDataCommandBuilder"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="value"/> is null, empty or white space.</exception>
internal HouseholdDataCommandBuilder AddMailAddressParameter(string value)
{
ArgumentNullGuard.NotNullOrWhiteSpace(value, nameof(value));
AddVarCharParameter("@mailAddress", value, 128);
return(this);
}
/// <summary>
/// Gets a food group by a given data providers foreign key.
/// </summary>
/// <param name="dataProvider">Data provider.</param>
/// <param name="foreignKeyValue">Foreign key value.</param>
/// <returns>Food group.</returns>
public virtual IFoodGroup FoodGroupGetByForeignKey(IDataProvider dataProvider, string foreignKeyValue)
{
ArgumentNullGuard.NotNull(dataProvider, nameof(dataProvider))
.NotNullOrWhiteSpace(foreignKeyValue, nameof(foreignKeyValue));
try
{
if (dataProvider.Identifier.HasValue == false)
{
throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.IllegalValue, dataProvider.Identifier, "Identifier"));
}
MySqlCommand command = FoodGroupProxy.BuildSystemDataCommandForSelecting(
"INNER JOIN ForeignKeys AS fk ON fk.ForeignKeyForIdentifier=fg.FoodGroupIdentifier WHERE fk.DataProviderIdentifier=@dataProviderIdentifier AND fk.ForeignKeyForTypes LIKE @foreignKeyForTypes AND fk.ForeignKeyValue=@foreignKeyValue",
systemCommandBuilder => systemCommandBuilder
.AddDataProviderIdentifierParameter(dataProvider.Identifier)
.AddForeignKeyForTypesLikeParameter(typeof(IFoodGroup))
.AddForeignKeyValueParameter(foreignKeyValue));
return(DataProvider.GetCollection <FoodGroupProxy>(command).FirstOrDefault());
}
catch (IntranetRepositoryException)
{
throw;
}
catch (Exception ex)
{
throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.RepositoryError, MethodBase.GetCurrentMethod().Name, ex.Message), ex);
}
}
/// <summary>
/// Adds a household name parameter to the command.
/// </summary>
/// <param name="value">The value for the household name.</param>
/// <returns>This instance of the <see cref="HouseholdDataCommandBuilder"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="value"/> is null, empty or white space.</exception>
internal HouseholdDataCommandBuilder AddHouseholdNameParameter(string value)
{
ArgumentNullGuard.NotNullOrWhiteSpace(value, nameof(value));
AddVarCharParameter("@name", value, 64);
return(this);
}
/// <summary>
/// Build a mockup for a foreign key to a domain object in the food waste domain.
/// </summary>
/// <param name="foreignKeyForIdentifier">Identifier for the domain object which has the foreign key.</param>
/// <param name="foreignKeyForType">Type on which has the foreign key.</param>
/// <param name="dataProvider">Data provider who owns the foreign key.</param>
/// <returns>Mockup for a foreign key to a to a domain object in the food waste domain.</returns>
public static IForeignKey BuildForeignKeyMock(Guid foreignKeyForIdentifier, Type foreignKeyForType, IDataProvider dataProvider = null)
{
ArgumentNullGuard.NotNull(foreignKeyForType, nameof(foreignKeyForType));
IForeignKey foreignKeyMock = MockRepository.GenerateMock <IForeignKey>();
foreignKeyMock.Stub(m => m.Identifier)
.Return(Guid.NewGuid())
.Repeat.Any();
foreignKeyMock.Stub(m => m.DataProvider)
.Return(dataProvider ?? BuildDataProviderMock())
.Repeat.Any();
foreignKeyMock.Stub(m => m.ForeignKeyForIdentifier)
.Return(foreignKeyForIdentifier)
.Repeat.Any();
foreignKeyMock.Stub(m => m.ForeignKeyForTypes)
.Return(new List <Type> {
typeof(IDomainObject), typeof(IIdentifiable), foreignKeyForType
})
.Repeat.Any();
foreignKeyMock.Stub(m => m.ForeignKeyValue)
.Return(Fixture.Create <string>())
.Repeat.Any();
return(foreignKeyMock);
}
/// <summary>
/// Danner en data provider, som benytter MySql.
/// </summary>
/// <param name="connectionStringSettings">Konfiguration for en connection streng.</param>
/// <exception cref="System.ArgumentNullException">Thrown when <paramref name="connectionStringSettings"/> is null.</exception>
public MySqlDataProvider(ConnectionStringSettings connectionStringSettings)
{
ArgumentNullGuard.NotNull(connectionStringSettings, nameof(connectionStringSettings));
_mySqlConnection = new MySqlConnection(connectionStringSettings.ConnectionString);
_clonedWithReusableConnection = false;
}
/// <summary>
/// Adds the parameter for the title.
/// </summary>
/// <param name="value">The value for the title.</param>
/// <returns>Command builder which can build command to the common repository.</returns>
/// <exception cref="System.ArgumentNullException">Thrown when the <paramref name="value"/> is null, empty or white space.</exception>
internal CommonCommandBuilder AddTitleParameter(string value)
{
ArgumentNullGuard.NotNullOrWhiteSpace(value, nameof(value));
AddVarCharParameter("@title", value, 50);
return(this);
}
/// <summary>
/// Gets whether the storage type is deletable from the data reader.
/// </summary>
/// <param name="dataReader">The data reader from which to read.</param>
/// <param name="columnName">The column name for value to read.</param>
/// <returns>Whether the storage type is deletable or not.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="dataReader"/> is null or <paramref name="columnName"/> is null, empty or white space.</exception>
private static bool GetDeletable(MySqlDataReader dataReader, string columnName)
{
ArgumentNullGuard.NotNull(dataReader, nameof(dataReader))
.NotNullOrWhiteSpace(columnName, nameof(columnName));
return(Convert.ToBoolean(dataReader.GetInt32(columnName)));
}
/// <summary>
/// Gets the appointment identifier from the data reader.
/// </summary>
/// <param name="dataReader">The data reader.</param>
/// <param name="columnName">Column name.</param>
/// <returns>Appointment identifier.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="dataReader"/> is null or when <paramref name="columnName"/> is null, empty or whitespace.</exception>
private static int GetAppointmentIdentifier(MySqlDataReader dataReader, string columnName)
{
ArgumentNullGuard.NotNull(dataReader, nameof(dataReader))
.NotNullOrWhiteSpace(columnName, nameof(columnName));
return(dataReader.GetInt32(columnName));
}
/// <summary>
/// Creates a command handler which handles a command for removing a household member from a given household on the current users household account.
/// </summary>
/// <param name="householdDataRepository">Implementation of a repository which can access household data for the food waste domain.</param>
/// <param name="claimValueProvider">Implementation of a provider which can resolve values from the current users claims.</param>
/// <param name="foodWasteObjectMapper">Implementation of an object mapper which can map objects in the food waste domain.</param>
/// <param name="specification">Implementation of a specification which encapsulates validation rules.</param>
/// <param name="commonValidations">Implementation of common validations.</param>
/// <param name="domainObjectValidations">Implementation of common validations used by domain objects in the food waste domain.</param>
/// <param name="exceptionBuilder">Implementation of a builder which can build exceptions.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="domainObjectValidations"/> is null.</exception>
public HouseholdRemoveHouseholdMemberCommandHandler(IHouseholdDataRepository householdDataRepository, IClaimValueProvider claimValueProvider, IFoodWasteObjectMapper foodWasteObjectMapper, ISpecification specification, ICommonValidations commonValidations, IDomainObjectValidations domainObjectValidations, IExceptionBuilder exceptionBuilder)
: base(householdDataRepository, claimValueProvider, foodWasteObjectMapper, specification, commonValidations, exceptionBuilder)
{
ArgumentNullGuard.NotNull(domainObjectValidations, nameof(domainObjectValidations));
_domainObjectValidations = domainObjectValidations;
}
/// <summary>
/// Gets an appointment time from the data reader.
/// </summary>
/// <param name="dataReader">The data reader.</param>
/// <param name="columnName">Column name.</param>
/// <returns>Appointment time.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="dataReader"/> is null or when <paramref name="columnName"/> is null, empty or whitespace.</exception>
private static TimeSpan GetAppointmentTime(MySqlDataReader dataReader, string columnName)
{
ArgumentNullGuard.NotNull(dataReader, nameof(dataReader))
.NotNullOrWhiteSpace(columnName, nameof(columnName));
return(dataReader.GetTimeSpan(columnName));
}
/// <summary>
/// Gets the name from the data reader.
/// </summary>
/// <param name="dataReader">The data reader from which to read.</param>
/// <param name="columnName">The column name for value to read.</param>
/// <returns>The name.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="dataReader"/> is null or <paramref name="columnName"/> is null, empty or white space.</exception>
private static string GetName(MySqlDataReader dataReader, string columnName)
{
ArgumentNullGuard.NotNull(dataReader, nameof(dataReader))
.NotNullOrWhiteSpace(columnName, nameof(columnName));
return(dataReader.GetString(columnName));
}
/// <summary>
/// Gets the appointment properties from the data reader.
/// </summary>
/// <param name="dataReader">The data reader.</param>
/// <param name="columnName">Column name.</param>
/// <returns>Appointment properties.</returns>
private static int GetAppointmentProperties(MySqlDataReader dataReader, string columnName)
{
ArgumentNullGuard.NotNull(dataReader, nameof(dataReader))
.NotNullOrWhiteSpace(columnName, nameof(columnName));
return(dataReader.IsDBNull(dataReader.GetOrdinal(columnName)) ? 0 : dataReader.GetInt32(columnName));
}
/// <summary>
/// Creates a builder which can build a database command tester.
/// </summary>
/// <param name="commandText">The expected command text.</param>
/// <param name="commandType">The expected command type.</param>
/// <param name="commandTimeout">The expected command timeout.</param>
public DbCommandTestBuilder(string commandText, CommandType commandType = CommandType.Text, int commandTimeout = 30)
{
ArgumentNullGuard.NotNullOrWhiteSpace(commandText, nameof(commandText));
IDataParameterCollection dataParameterCollection = MockRepository.GenerateMock <IDataParameterCollection>();
dataParameterCollection.Stub(m => m.Count)
.WhenCalled(e => e.ReturnValue = _dataParameterCollection.Count)
.Return(0)
.Repeat.Any();
dataParameterCollection.Stub(m => m[Arg <string> .Is.Anything])
.WhenCalled(e => e.ReturnValue = _dataParameterCollection.SingleOrDefault(m => string.CompareOrdinal((string)e.Arguments.ElementAt(0), m.ParameterName) == 0))
.Return(null)
.Repeat.Any();
_expectedDbCommand = MockRepository.GenerateMock <IDbCommand>();
_expectedDbCommand.Stub(m => m.CommandText)
.Return(commandText)
.Repeat.Any();
_expectedDbCommand.Stub(m => m.CommandType)
.Return(commandType)
.Repeat.Any();
_expectedDbCommand.Stub(m => m.CommandTimeout)
.Return(commandTimeout)
.Repeat.Any();
_expectedDbCommand.Stub(m => m.Parameters)
.WhenCalled(e => e.ReturnValue = dataParameterCollection)
.Return(null)
.Repeat.Any();
}
/// <summary>
/// Tests the database command.
/// </summary>
/// <param name="expected">The expected database command.</param>
/// <param name="actual">The actual database command.</param>
/// <param name="resultBuilder">The result builder.</param>
private static void CommandTester(IDbCommand expected, IDbCommand actual, StringBuilder resultBuilder)
{
ArgumentNullGuard.NotNull(expected, nameof(expected))
.NotNull(actual, nameof(actual))
.NotNull(resultBuilder, nameof(resultBuilder));
if (string.CompareOrdinal(expected.CommandText, actual.CommandText) != 0)
{
resultBuilder.AppendLine("CommandText does not match:");
resultBuilder.AppendLine($"- Expected:\t{expected.CommandText}");
resultBuilder.AppendLine($"- But was:\t{actual.CommandText}");
}
if (expected.CommandType != actual.CommandType)
{
resultBuilder.AppendLine("CommandType does not match:");
resultBuilder.AppendLine($"- Expected:\t{expected.CommandType}");
resultBuilder.AppendLine($"- But was:\t{actual.CommandType}");
}
if (expected.CommandTimeout != actual.CommandTimeout)
{
resultBuilder.AppendLine("CommandTimeout does not match:");
resultBuilder.AppendLine($"- Expected:\t{expected.CommandTimeout}");
resultBuilder.AppendLine($"- But was:\t{actual.CommandTimeout}");
}
}
