private DbTestSqlResult ExecuteAct(IDbTestRunnerContext context, DbTestRunnerResult result, IDisposable dbHandle)
{
var request = OnAct(context, dbHandle, this.TestOutputHelper);
result.TestPhase = "ACT";
return(ExecuteTestPhase(result, "ACT", request));
}
/// <summary>
/// public method for running this test
/// </summary>
protected DbTestRunnerResult ExecuteArrangeActAssert()
{
var context = this.TestFixture.Context;
var result = new DbTestRunnerResult {
TestName = this.Name
};
TransactionScope transactionScope = null;
try
{
using (transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
try
{
using (var handle = ProduceDbHandle())
{
this.handleInstance = handle;
var arrangeResult = ExecuteArrange(context, result, handle);
if (arrangeResult.IsSuccessful)
{
var actResult = ExecuteAct(context, result, handle);
if (actResult.IsSuccessful)
{
ExecuteAssert(context, result, actResult.Data, handle);
}
}
this.handleInstance = null;
}
}
finally
{
this.handleInstance = null;
if (context.CommitTransactionScope)
{
transactionScope.Complete();
}
}
}
}
// catch and re-throw assertions
catch (XunitException)
{
throw;
}
catch (Exception e)
{
result = DbTestRunnerResult.Failure("Error running DbTest", e);
}
finally
{
transactionScope?.Dispose();
}
DumpRunLog(result);
return(result);
}
public static DbTestRunnerResult Failure(string message, Exception e = null)
{
var result = new DbTestRunnerResult
{
Exception = e,
IsSuccessful = false
};
result.Logs.Add($"Error - {message}");
return(result);
}
/// <summary>
/// used when the CommandType is TableDirect.
/// </summary>
private DbTestSqlResult ExecuteSqlTableDirectRequest(SqlRequest request, DbTestRunnerResult result, string phaseName)
{
var sqlResult = new DbTestSqlResult();
try
{
// Create a new command using the same connection as the data context
using (var cmd = this.GetDbConnection().CreateCommand())
{
// Set the command parameters
foreach (var p in request.Parameters.Select(i => i.Value))
{
result.Logs.Add($"{phaseName} Sql Parameter:{p.ParameterName} = {p.Value}");
cmd.Parameters.Add(p);
}
if (cmd.Connection.State != ConnectionState.Open)
{
cmd.Connection.Open();
}
// build up the sql command object
cmd.CommandText = $"Select * From {request.SqlToExecute}";
result.Logs.Add($"{phaseName} Table Direct Sql: {cmd.CommandText}");
cmd.CommandType = CommandType.Text;
// Execute the command via a data reader and use it to load data tables; one for each result set returned from the sql.
using (var rdr = cmd.ExecuteReader())
{
do
{
var dt = new DataTable();
dt.Load(rdr);
sqlResult.Data.Add(dt);
result.Logs.Add($"{phaseName} Phase: DataTable[{sqlResult.Data.Count - 1}] read {dt.Rows.Count} rows(s).");
} while (!rdr.IsClosed && rdr.NextResult());
}
result.Logs.Add($"{phaseName} Phase: Read {sqlResult.Data.Count} result set(s).");
}
sqlResult.IsSuccessful = true;
}
catch (Exception e)
{
sqlResult.Exception = e;
sqlResult.IsSuccessful = false;
}
return(sqlResult);
}
public static DbTestRunnerResult Success(string message = null)
{
var result = new DbTestRunnerResult
{
IsSuccessful = true,
};
if (!string.IsNullOrEmpty(message))
{
result.Logs.Add(message);
}
return(result);
}
/// <summary>
/// Used when CommandType is StoredProcedure
/// </summary>
private DbTestSqlResult ExecuteSqlStoredProcedureRequest(SqlRequest request, DbTestRunnerResult result, string phaseName)
{
var sqlResult = new DbTestSqlResult();
try
{
// var dataTable = new DataTable();
var dataset = new DataSet();
// Create a new command using the same connection as the data context
using (var cmd = GetDbConnection().CreateCommand())
{
if (cmd.Connection.State != ConnectionState.Open)
{
cmd.Connection.Open();
}
// build up the sql command object
cmd.CommandText = request.SqlToExecute;
cmd.CommandType = CommandType.StoredProcedure;
// Set the command parameters
foreach (var p in request.Parameters.Select(i => i.Value))
{
cmd.Parameters.Add(p);
}
result.Logs.Add($"{phaseName} Stored Procedure: {cmd.CommandText}");
// Execute the command via a data adapter and use it to load a data set
using (var dataAdapter = new SqlDataAdapter(cmd))
{
//dataAdapter.Fill(dataTable);
dataAdapter.Fill(dataset);
}
}
// populate the sqlResult data tables with the tables filled by the adapter
sqlResult.Data.AddRange(dataset.Tables.Cast <DataTable>());
//sqlResult.Data.Add(dataTable);
sqlResult.IsSuccessful = true;
}
catch (Exception e)
{
sqlResult.Exception = e;
sqlResult.IsSuccessful = false;
}
return(sqlResult);
}
protected void DumpRunLog(DbTestRunnerResult result)
{
if (result == null)
{
return;
}
this.TestOutputHelper?.WriteLine($"[{DateTime.Now:s}]{result.TestName}");
foreach (var msg in result.Logs)
{
TestOutputHelper?.WriteLine(msg);
}
if (result.Exception != null)
{
TestOutputHelper?.WriteLine(result.Exception.ToString());
}
}
/// <summary>
/// Invokes the ASSERT hook method
/// </summary>
// ReSharper disable once UnusedParameter.Local
private void ExecuteAssert(IDbTestRunnerContext context, DbTestRunnerResult result, List <DataTable> data, IDisposable dbHandle)
{
try
{
result.TestPhase = "ASSERT";
result.IsSuccessful = true;
result.Logs.Add("ASSERT Phase: Running test Assertions.");
this.OnAssert(data == null || !data.Any() ? null : data[0], dbHandle, data?.ToArray(), this.TestOutputHelper);
result.Logs.Add("ASSERT Phase: All assertions passed.");
}
catch (XunitException)
{
// we actually just want to re-throw the current exception to maintain the stack trace
throw;
}
catch (Exception e)
{
// non-assertion exception occurred.
result.Logs.Add($"Error asserting state of data. {e}");
result.Exception = e;
result.IsSuccessful = false;
}
}
/// <summary>
/// Executes the sql requests
/// </summary>
protected DbTestSqlResult ExecuteTestPhase(DbTestRunnerResult result, string phaseName, SqlRequest request)
{
var phaseResult = new DbTestSqlResult();
try
{
if (request == null)
{
return(DbTestSqlResult.Success);
}
// if we're supposed to commit the data context changes before running the sql, do so now.
if (request.DataContextCommitPoint == DataContextCommitPoint.BeforeRunningSql)
{
var contextRowsAffected = this.CommitChanges();
result.Logs.Add($"{phaseName} Phase: Commited Data Context prior to executing sql. Rows Affected: {contextRowsAffected}");
}
if (request.IsEmpty)
{
return(DbTestSqlResult.Success);
}
// Run the sql, we have different execution strategies based on the command types
switch (request.CommandType)
{
case CommandType.Text:
phaseResult = this.ExecuteSqlTextRequest(request, result, phaseName);
break;
case CommandType.StoredProcedure:
phaseResult = this.ExecuteSqlStoredProcedureRequest(request, result, phaseName);
break;
case CommandType.TableDirect:
phaseResult = this.ExecuteSqlTableDirectRequest(request, result, phaseName);
break;
default:
throw new Exception("Unsupported Command Type");
}
// if there was a problem running the sql command, stop executing now
if (!phaseResult.IsSuccessful)
{
return(phaseResult);
}
// if we're supposed to commit the data context changes after running the sql, do so now.
if (request.DataContextCommitPoint == DataContextCommitPoint.AfterRunningSql)
{
var contextRowsAffected = this.CommitChanges();
result.Logs.Add($"{phaseName} Phase: Commited Data Context prior to executing sql. Rows Affected: {contextRowsAffected}");
}
// if we got this far, the test executed successfully, set the return value
phaseResult.IsSuccessful = true;
}
catch (Exception e)
{
// runtime exception executing the test.
result.Exception = e;
result.Logs.Add($"Error attempting to execute {phaseName} sql. {e.GetType().Name} - {e.Message}");
phaseResult.IsSuccessful = false;
throw;
}
// set the overall result success status based on how this command was executed
result.IsSuccessful = phaseResult.IsSuccessful;
result.TestPhase = phaseName;
return(phaseResult);
}
