public List <VerificationFailure> Verify(InterceptionProcessingData processingData)
{
var returnVal = new List <VerificationFailure>();
if (processingData.BoundaryType != BoundaryType.Exit)
{
return(returnVal);
}
if (_helper.IsUnserializable(processingData.ReturnType))
{
returnVal.Add(new TypeSerializationFailure(processingData.ReturnType));
}
else
{
var res = _serializer.Serialize(processingData.ReturnValue);
if (!res.Success)
{
_helper.AddUnserializableType(processingData.ReturnType);
returnVal.Add(new TypeSerializationFailure(processingData.ReturnType));
}
}
return(returnVal);
}
public List <VerificationFailure> Verify(InterceptionProcessingData processingData)
{
var returnVal = new List <VerificationFailure>();
var instanceType = processingData.TargetInstance.GetType();
if (processingData.BoundaryType != BoundaryType.Entry)
{
return(returnVal);
}
if (_helper.IsUnserializable(instanceType))
{
returnVal.Add(new TypeSerializationFailure(instanceType));
}
else
{
var serResult = _serializer.Serialize(processingData.TargetInstance);
if (!serResult.Success)
{
_helper.AddUnserializableType(instanceType);
returnVal.Add(new TypeSerializationFailure(instanceType));
}
}
return(returnVal);
}
private void ProcessExit(InterceptionProcessingData data, List <RecordingMethod> methods, Guid executingMethodId, int threadId)
{
var subMethod = GetSubMethod(executingMethodId, methods);
var hasError = HasSerializationErrors(data);
if (subMethod != null)
{
if (hasError)
{
ClearMethodFromSubId(executingMethodId, threadId);
}
else
{
subMethod.CloseOutMethodWithReturnVal(data.ReturnValue);
}
}
var executingMethod = methods.FirstOrDefault(x => x.Identifier == executingMethodId);
if (executingMethod != null)
{
if (!hasError)
{
executingMethod.CloseOutMethodWithReturnVal(data.ReturnValue);
OnMethodRecordingComplete(new MethodRecordingCompleteEventArgs(executingMethod));
ClearMethod(executingMethodId, threadId);
}
else
{
ClearMethod(executingMethodId, threadId);
}
}
_executionStack.ProcessExit(threadId);
}
private void ProcessEntry(InterceptionProcessingData data, List <RecordingMethod> methods, Guid executingMethodId, int threadId)
{
Guid newMethodId = Guid.NewGuid();
//add this as a method
if (!HasSerializationErrors(data))
{
var serInstance = _serializationHelper.Serialize(data.TargetInstance);
if (!serInstance.Success)
{
throw new AutoTestEngineException($"Unable to serialize type {data.TargetInstance.ToString()} despite not having a serialization failure on the processing datat context");
}
var newMethod = new RecordingMethod(newMethodId, serInstance.SerializedValue, data.MethodArgs, data.Method);
methods.Add(newMethod);
}
//add this as a sub-method if applicable
var executingMethod = methods.FirstOrDefault(x => x.Identifier == executingMethodId);
if (executingMethod != null)
{
var subMethod = new RecordedSubMethod(newMethodId, data.TargetType, data.MethodArgs, data.ReturnType, data.Method);
executingMethod.SubMethods.Add(subMethod);
}
_executionStack.ProcessEntry(threadId, newMethodId);
}
public void Return_Val_Verifier_Test_Ent_Data_No_Serialization_Errors()
{
var SUT = new ReturnValVerifier(_successSerHelper.Object, _successUnserializableTypehelper.Object);
var data = new InterceptionProcessingData(DataHelper.DateTimeAddDaysData.Entry, _config);
var res = SUT.Verify(data);
Assert.IsTrue(!res.Any());
}
public void Instance_Serialization_Verifier_Test_Failed_Serialization_Fails_Verifier()
{
var SUT = new InstanceSerializationVerifier(_failSerHelper.Object, _successUnserializableTypehelper.Object);
var data = new InterceptionProcessingData(DataHelper.DateTimeAddDaysData.Entry, _config);
var res = SUT.Verify(data);
Assert.IsTrue(res.Any());
}
public void Instance_Serialization_Verifier_Test_Exc_Data_Serialization_Errors()
{
var SUT = new InstanceSerializationVerifier(_successSerHelper.Object, _failUnserializableTypehelper.Object);
var data = new InterceptionProcessingData(DataHelper.DateTimeAddDaysData.Exception, _config);
var res = SUT.Verify(data);
Assert.IsTrue(!res.Any());
}
public void Input_Parameter_Verifier_Test_Ent_Data_Serialization_Errors()
{
var SUT = new InputParameterVerifier(_successSerHelper.Object, _failUnserializableTypehelper.Object);
var data = new InterceptionProcessingData(DataHelper.DateTimeAddDaysData.Entry, _config);
var res = SUT.Verify(data);
Assert.IsTrue(res.Any());
}
public void Processing_Data_Test_Class_Level_Attributes()
{
var entry = new InterceptionEntryModel(_instance, _args, GetAttMethodBase());
var processingModel = new InterceptionProcessingData(entry, new EngineConfiguration());
Assert.IsTrue(processingModel.ClassAttributes.Count == 1);
Assert.IsTrue(processingModel.ClassAttributes.Contains(typeof(AutoTestEngine.Attributes.AutoTest)));
}
public void Return_Val_Verifier_Test_Exit_Serialization_Fails_Verifier()
{
var SUT = new ReturnValVerifier(_failSerHelper.Object, _successUnserializableTypehelper.Object);
var data = new InterceptionProcessingData(DataHelper.DateTimeAddDaysData.Exit, _config);
var res = SUT.Verify(data);
Assert.IsTrue(res.Any());
}
public void Return_Val_Verifier_Test_Failed_Serialization_Adds_To_DB()
{
var SUT = new ReturnValVerifier(_failSerHelper.Object, _successUnserializableTypehelper.Object);
var data = new InterceptionProcessingData(DataHelper.DateTimeAddDaysData.Exit, _config);
var res = SUT.Verify(data);
Assert.IsTrue(res.Any());
_successUnserializableTypehelper.Verify(x => x.AddUnserializableType(It.IsAny <Type>()), Times.Once);
}
/// <summary>
/// Process the interception data
/// </summary>
/// <param name="processingData">data from interception</param>
/// <returns>Result of process</returns>
public ProcessResult Process(InterceptionProcessingData processingData)
{
foreach (var process in _processes)
{
if (process.ShouldExecuteProcess(processingData))
{
return(process.ExecuteProcess(processingData));
}
}
return(new ProcessResult());
}
public void ProcessingDataExitInitTest()
{
var exitModel = DataHelper.MathPowerData.Exit;
var procData = new InterceptionProcessingData(exitModel, _config);
Assert.IsTrue(procData.BoundaryType == BoundaryType.Exit);
Assert.IsTrue(procData.Exception == null);
Assert.IsTrue(procData.Method != null);
Assert.IsTrue(procData.ReturnType != null);
Assert.IsTrue(procData.ReturnValue != null);
Assert.IsTrue(procData.TargetInstance == null);
Assert.IsTrue(procData.VerificationFailures != null);
}
public void Execution_Recorder_Non_Unit_Test_Config_Should_Run_Process()
{
var SUT = new ExecutionRecorderProcess(_manager, _methodHelper);
var config = new EngineConfiguration()
{
IsUnitTesting = false
};
var procData = new InterceptionProcessingData(_entryModel, config);
Assert.IsTrue(SUT.ShouldExecuteProcess(procData));
}
public List <VerificationFailure> Verify(InterceptionProcessingData processingData)
{
var res = new List <VerificationFailure>();
if (processingData.BoundaryType != BoundaryType.Entry)
{
return(res);
}
foreach (var arg in processingData.MethodArgs)
{
res.AddRange(ProcessArg(arg));
}
return(res);
}
/// <summary>
/// Processes each interception in a pipeline
/// </summary>
/// <param name="processingData">the data of this interception</param>
/// <returns>Pipeline result</returns>
public VerificationPipelineResult VerifyInterception(InterceptionProcessingData processingData)
{
var result = new VerificationPipelineResult();
foreach (var verifier in _verifiers)
{
var verificationResult = verifier.Verify(processingData);
result.AddFailures(verificationResult);
if (result.HasCriticalFailure)
{
break;
}
}
processingData.AddVerificationFailures(result.Failures);
return(result);
}
private void ProcessException(InterceptionProcessingData data, List <RecordingMethod> methods, Guid executingMethodId, int threadId)
{
var subMethod = GetSubMethod(executingMethodId, methods);
if (subMethod != null)
{
subMethod.CloseOutMethodWithException(data.Exception);
}
var executingMethod = methods.FirstOrDefault(x => x.Identifier == executingMethodId);
if (executingMethod != null)
{
executingMethod.CloseOutMethodWithException(data.Exception);
OnMethodRecordingComplete(new MethodRecordingCompleteEventArgs(executingMethod));
ClearMethod(executingMethodId, threadId);
}
_executionStack.ProcessException(threadId);
}
public void Processing_Data_Test_All_Constructors()
{
var entry = new InterceptionEntryModel(_instance, _args, GetAttMethodBase());
var processingModel = new InterceptionProcessingData(entry, new EngineConfiguration());
Assert.IsTrue(processingModel.MethodAttributes.Count == 1);
Assert.IsTrue(processingModel.MethodAttributes.Contains(typeof(AutoTestEngine.Attributes.AutoTest)));
var exit = new InterceptionExitModel(_instance, _returnVal, GetAttMethodBase());
processingModel = new InterceptionProcessingData(exit, new EngineConfiguration());
Assert.IsTrue(processingModel.MethodAttributes.Count == 1);
Assert.IsTrue(processingModel.MethodAttributes.Contains(typeof(AutoTestEngine.Attributes.AutoTest)));
var exception = new InterceptionExceptionModel(_instance, GetAttMethodBase(), new Exception());
processingModel = new InterceptionProcessingData(exception, new EngineConfiguration());
}
public void ProcessCapture(InterceptionProcessingData processingData)
{
var threadId = _threadProvider.GetThreadId();
var methods = _executionCache.GetMethods(threadId);
var executingMethodId = _executionStack.ExecutingGuid(threadId);
switch (processingData.BoundaryType)
{
case BoundaryType.Entry:
ProcessEntry(processingData, methods, executingMethodId, threadId);
break;
case BoundaryType.Exception:
ProcessException(processingData, methods, executingMethodId, threadId);
break;
case BoundaryType.Exit:
ProcessExit(processingData, methods, executingMethodId, threadId);
break;
}
}
private bool HasSerializationErrors(InterceptionProcessingData data)
{
return(data.VerificationFailures.Any(x => x.FailureId.Equals(Failures.SerializationError)));
}
public bool ShouldExecuteProcess(InterceptionProcessingData processingData)
{
return(!processingData.Configuration.IsUnitTesting);
}
public ProcessResult ExecuteProcess(InterceptionProcessingData processingData)
{
_methodManager.ProcessCapture(processingData);
return(new ProcessResult());
}
