public void ScanAssembliesForCheckAndGenerateReport()
{
var report = new FullRunDescription();
// scan all assemblies
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
// get all test fixtures
foreach (var type in
assembly.GetTypes()
.Where(
type =>
((type.GetInterface("IForkableFluentAssertion") != null &&
(type.Attributes & TypeAttributes.Abstract) == 0) ||
type.GetCustomAttributes(typeof(ExtensionAttribute), false).Length > 0) &&
((type.Attributes & TypeAttributes.Public) == TypeAttributes.Public)))
{
try
{
// enumerate public methods
IEnumerable <MethodInfo> tests =
type.GetMethods(
BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static
| BindingFlags.DeclaredOnly)
.Where(
method =>
method.MemberType == MemberTypes.Method &&
((method.Attributes & MethodAttributes.SpecialName) == 0));
var publicMethods = tests as IList <MethodInfo> ?? tests.ToList();
if (publicMethods.Count > 0)
{
// run all tests
foreach (var checkMethod in publicMethods)
{
CheckDescription desc = RunnerHelper.AnalyzeSignature(checkMethod);
if (desc != null)
{
RunnerHelper.Log(string.Format("Method :{0}.{1}({2})", type.Name, checkMethod.Name, desc.CheckedType.Name));
report.AddEntry(desc);
}
}
}
}
catch (Exception e)
{
RunnerHelper.Log(string.Format("Exception while working on type:{0}\n{1}", type.FullName, e));
}
}
}
const string Name = "FluentChecks.xml";
report.Save(Name);
Debug.Write(string.Format("Report generated in {0}", Path.GetFullPath(Name)));
}
public void AddEntry(CheckDescription desc)
{
foreach (TypeChecks typeCheckse in this.runDescription)
{
if (typeCheckse.CheckedType == desc.CheckedType)
{
typeCheckse.AddCheck(desc);
return;
}
}
var addedType = new TypeChecks(desc.CheckedType);
addedType.AddCheck(desc);
this.runDescription.Add(addedType);
}
public void AddEntry(CheckDescription desc)
{
foreach (TypeChecks typeCheckse in this.runDescription)
{
if (typeCheckse.CheckedType == desc.CheckedType)
{
typeCheckse.AddCheck(desc);
return;
}
}
var addedType = new TypeChecks(desc.CheckedType);
addedType.AddCheck(desc);
this.runDescription.Add(addedType);
}
public void AddCheck(CheckDescription description)
{
foreach (CheckList checkList in this.checks)
{
if (checkList.CheckName == description.CheckName)
{
checkList.AddCheck(description);
return;
}
}
var toAdd = new CheckList();
toAdd.CheckName = description.CheckName;
toAdd.AddCheck(description);
this.checks.Add(toAdd);
}
private static CheckDescription GetCheckAndType(FluentCheckException fluExc)
{
// identify failing test
var trace = new StackTrace(fluExc);
// get fluententrypoint stackframe
var frameIndex = trace.FrameCount - 2;
if (frameIndex < 0)
{
frameIndex = 0;
}
var frame = trace.GetFrame(frameIndex);
// get method
var method = frame.GetMethod();
return(CheckDescription.AnalyzeSignature(method));
}
public static CheckDescription AnalyzeSignature(MethodBase method)
{
var result = new CheckDescription { Check = method };
if (method.IsStatic)
{
#if !CORE
// check if this is an extension method
if (method.GetCustomAttributes(typeof(ExtensionAttribute), false).Length > 0)
{
var parameters = method.GetParameters();
var param = parameters[0];
var paramType = param.ParameterType;
if (!paramType.IsGenericType)
{
// this is not an check implementation
return null;
}
// if it is specific to chains
if (paramType.Name == "ICheckLink`1")
{
paramType = paramType.GetGenericArguments()[0];
}
if (paramType.Name == "IExtendableCheckLink`1"
|| paramType.Name == "IExtendableCheckLink`2"
|| paramType.Name == "ICheck`1"
|| paramType.GetInterface("ICheck`1") != null
|| paramType.Name == "IStructCheck`1"
|| paramType.Name == "ICodeCheck`1")
{
result.entryPoint = paramType.Name == "IStructCheck`1" ? "ThatEnum" : "That";
var testedtype = paramType.GetGenericArguments()[0];
if (testedtype.IsGenericParameter)
{
testedtype = testedtype.BaseType;
}
result.CheckedType = testedtype;
// get other parameters
result.CheckParameters = new List<Type>(parameters.Length - 1);
for (var i = 1; i < parameters.Length; i++)
{
result.CheckParameters.Add(parameters[i].ParameterType);
}
}
else
{
// this is not an check implementation
return null;
}
// identify type subjected to test
}
else
{
// unexpected case: check is a static method which is not an extension method
return null;
}
}
else
{
result.entryPoint = "That";
if (method.DeclaringType == null)
{
return null;
}
// this is an instance method, tested type is part of type defintion
Type scanning = method.DeclaringType.GetInterface("ICheck`1");
if (scanning != null && scanning.IsGenericType)
{
// the type implements ICheck<T>
result.CheckedType = scanning.IsGenericType ? scanning.GetGenericArguments()[0] : null;
if (result != null && result.CheckedType.IsGenericType)
{
result.CheckedType = result.CheckedType.BaseType;
}
// get other parameters
result.CheckParameters = new List<Type>();
foreach (var t in method.GetParameters())
{
result.CheckParameters.Add(t.ParameterType);
}
}
else
{
// type does not implement ICheck<T>, we try to find a 'Value' property
var prop = method.DeclaringType.GetProperty("Value", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
if (prop != null)
{
result.CheckedType = prop.PropertyType;
// get other parameters
result.CheckParameters = new List<Type>();
foreach (var t in method.GetParameters())
{
result.CheckParameters.Add(t.ParameterType);
}
}
else
{
// not a check method
Debug.WriteLine(string.Format("Type {0} needs to implement a Value property (method {1})", method.DeclaringType.Name, method.Name));
}
}
#endif
}
return result;
}
public void AddCheck(CheckDescription description)
{
this.checks.Add(description);
}
public void AddCheck(CheckDescription description)
{
foreach (CheckList checkList in this.checks)
{
if (checkList.CheckName == description.CheckName)
{
checkList.AddCheck(description);
return;
}
}
var toAdd = new CheckList();
toAdd.CheckName = description.CheckName;
toAdd.AddCheck(description);
this.checks.Add(toAdd);
}
public static CheckDescription AnalyzeSignature(MethodBase method)
{
var result = new CheckDescription {
Check = method
};
if (method.IsStatic)
{
// check if this is an extension method
if (method.GetCustomAttributes(typeof(ExtensionAttribute), false).Length > 0)
{
ParameterInfo[] parameters = method.GetParameters();
ParameterInfo param = parameters[0];
Type paramType = param.ParameterType;
if (!paramType.IsGenericType)
{
// this is not an check implementation
return(null);
}
if (paramType.Name != "IFluentAssertion`1" && paramType.GetInterface("IFluentAssertion`1") == null)
{
// this is not an check implementation
return(null);
}
// identify type subjected to test
var testedtype = paramType.GetGenericArguments()[0];
result.CheckedType = testedtype;
// get other parameters
result.CheckParameters = new List <Type>(parameters.Length - 1);
for (int i = 1; i < parameters.Length; i++)
{
result.CheckParameters.Add(parameters[i].ParameterType);
}
}
else
{
// unexpected case: check is a static method which is not an extension method
return(null);
}
}
else
{
if (method.DeclaringType == null)
{
return(null);
}
// this is an instance method, tested type is part of type defintion
Type scanning = method.DeclaringType.GetInterface("IFluentAssertion`1");
if (scanning != null && scanning.IsGenericType)
{
// the type implements IFluentAssertion<T>
result.CheckedType = scanning.IsGenericType ? scanning.GetGenericArguments()[0] : null;
// get other parameters
result.CheckParameters = new List <Type>();
foreach (ParameterInfo t in method.GetParameters())
{
result.CheckParameters.Add(t.ParameterType);
}
}
else
{
// type does not implement IFluentAssertion<T>, we try to find a 'Value' property
var prop = method.DeclaringType.GetProperty("Value");
if (prop != null)
{
result.CheckedType = prop.PropertyType;
// get other parameters
result.CheckParameters = new List <Type>();
foreach (ParameterInfo t in method.GetParameters())
{
result.CheckParameters.Add(t.ParameterType);
}
}
else
{
// not a check method
Debug.WriteLine(string.Format("Type {0} needs to implement a Value property (method {1})", method.DeclaringType.Name, method.Name));
}
}
}
return(result);
}
public static void RunMethod(MethodInfo specificTest, object test, FullRunDescription report)
{
try
{
specificTest.Invoke(test, new object[] { });
}
catch (Exception e)
{
if (specificTest.GetCustomAttributes(typeof(ExpectedExceptionAttribute), false).Length == 0)
{
throw;
}
Type expectedType =
((ExpectedExceptionAttribute)
specificTest.GetCustomAttributes(typeof(ExpectedExceptionAttribute), false)[0]).ExpectedException;
if (e.InnerException != null)
{
if (e.InnerException is FluentAssertionException)
{
var fluExc = e.InnerException as FluentAssertionException;
Type testedtype;
CheckDescription desc = GetCheckAndType(fluExc);
MethodBase method = desc.Check;
testedtype = desc.CheckedType;
desc.ErrorSampleMessage = fluExc.Message;
// are we building a report
if (report != null)
{
Log(
string.Format(
"Check.That({1} sut).{0} failure message\n****\n{2}\n****",
method.Name,
testedtype.Name,
fluExc.Message));
report.AddEntry(desc);
}
return;
}
if (report != null)
{
Log(
string.Format(
"{0} did not generate a FLUENT ASSERTION:\n{1}",
specificTest.Name,
e.InnerException.Message));
}
if (e.InnerException.GetType() != expectedType && expectedType != null)
{
throw;
}
}
else
{
if (report != null)
{
Log(string.Format("{0} failed to run:\n{1}", specificTest.Name, e));
}
throw;
}
}
}
public void AddCheck(CheckDescription description)
{
this.checks.Add(description);
}
public void ScanAssembliesForCheckAndGenerateReport()
{
var report = new FullRunDescription();
// scan all assemblies
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
if (assembly.GetName().Name == "MonoDevelop.NUnit")
{
// skip MonoDevelop.NUnit assembly because GetTypes fails
continue;
}
try
{
// get all test fixtures
foreach (var type in
assembly.GetTypes()
.Where(
type =>
((type.GetInterface("IForkableCheck") != null &&
(type.Attributes & TypeAttributes.Abstract) == 0) ||
type.GetCustomAttributes(typeof(ExtensionAttribute), false).Length > 0) &&
((type.Attributes & TypeAttributes.Public) == TypeAttributes.Public)))
{
try
{
// enumerate public methods
IEnumerable <MethodInfo> tests =
type.GetMethods(
BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static
| BindingFlags.DeclaredOnly)
.Where(
method =>
method.MemberType == MemberTypes.Method &&
((method.Attributes & MethodAttributes.SpecialName) == 0));
var publicMethods = tests as IList <MethodInfo> ?? tests.ToList();
if (publicMethods.Count > 0)
{
// scan all methods
foreach (var checkMethod in publicMethods)
{
try
{
if (checkMethod.Name == "ForkInstance")
{
// skip forkinstance
continue;
}
var desc = CheckDescription.AnalyzeSignature(checkMethod);
if (desc != null)
{
if (desc.CheckedType == null)
{
RunnerHelper.Log(string.Format("Failed to identify checked type on test {0}", checkMethod.Name));
}
else
{
RunnerHelper.Log(string.Format("Method :{0}.{1}({2})", type.Name, checkMethod.Name, desc.CheckedType.Name));
report.AddEntry(desc);
}
}
}
catch (Exception e)
{
RunnerHelper.Log(string.Format("Exception while assessing test {2} on type:{0}\n{1}", type.FullName, e, checkMethod.Name));
}
}
}
}
catch (Exception e)
{
RunnerHelper.Log(string.Format("Exception while working on type:{0}\n{1}", type.FullName, e));
}
}
}
catch (Exception e)
{
RunnerHelper.Log(string.Format("Exception while working on assembly:{0}\n{1}", assembly.FullName, e));
throw new ApplicationException(string.Format("Exception while working on assembly:{0}\n{1}", assembly.FullName, e));
}
}
// xml save
const string Name = "FluentChecks.xml";
report.Save(Name);
const string Name2 = "FluentChecks.csv";
// csv file
using (var writer = new StreamWriter(Name2, false))
{
foreach (var typeChecks in report.RunDescription)
{
foreach (var checkList in typeChecks.Checks)
{
foreach (var signature in checkList.CheckSignatures)
{
var message = string.Format(
"{0};{1};{2}", typeChecks.CheckedType.TypeToStringProperlyFormated(true), checkList.CheckName, signature.Signature);
writer.WriteLine(message);
}
}
}
}
Debug.Write(string.Format("Report generated in {0}", Path.GetFullPath(Name)));
Debug.Write(string.Format("Report generated in {0}", Path.GetFullPath(Name2)));
}
public static CheckDescription AnalyzeSignature(MethodBase method)
{
var result = new CheckDescription {
Check = method
};
if (method.IsStatic)
{
// check if this is an extension method
if (method.GetCustomAttributes(typeof(ExtensionAttribute), false).Length > 0)
{
var parameters = method.GetParameters();
var param = parameters[0];
var paramType = param.ParameterType;
if (!paramType.IsGenericType)
{
// this is not an check implementation
return(null);
}
// if it is specific to chains
if (paramType.Name == "ICheckLink`1")
{
paramType = paramType.GetGenericArguments()[0];
}
if (paramType.Name == "IExtendableCheckLink`1" ||
paramType.Name == "IExtendableCheckLink`2" ||
paramType.Name == "ICheck`1" ||
paramType.GetInterface("ICheck`1") != null ||
paramType.Name == "IStructCheck`1" ||
paramType.Name == "ICodeCheck`1")
{
result.entryPoint = paramType.Name == "IStructCheck`1" ? "ThatEnum" : "That";
var testedtype = paramType.GetGenericArguments()[0];
if (testedtype.IsGenericParameter)
{
testedtype = testedtype.BaseType;
}
result.CheckedType = testedtype;
// get other parameters
result.CheckParameters = new List <Type>(parameters.Length - 1);
for (var i = 1; i < parameters.Length; i++)
{
result.CheckParameters.Add(parameters[i].ParameterType);
}
}
else
{
// this is not an check implementation
return(null);
}
// identify type subjected to test
}
else
{
// unexpected case: check is a static method which is not an extension method
return(null);
}
}
else
{
result.entryPoint = "That";
if (method.DeclaringType == null)
{
return(null);
}
// this is an instance method, tested type is part of type defintion
Type scanning = method.DeclaringType.GetInterface("ICheck`1");
if (scanning != null && scanning.IsGenericType)
{
// the type implements ICheck<T>
result.CheckedType = scanning.IsGenericType ? scanning.GetGenericArguments()[0] : null;
if (result != null && result.CheckedType.IsGenericType)
{
result.CheckedType = result.CheckedType.BaseType;
}
// get other parameters
result.CheckParameters = new List <Type>();
foreach (var t in method.GetParameters())
{
result.CheckParameters.Add(t.ParameterType);
}
}
else
{
// type does not implement ICheck<T>, we try to find a 'Value' property
var prop = method.DeclaringType.GetProperty("Value", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
if (prop != null)
{
result.CheckedType = prop.PropertyType;
// get other parameters
result.CheckParameters = new List <Type>();
foreach (var t in method.GetParameters())
{
result.CheckParameters.Add(t.ParameterType);
}
}
else
{
// not a check method
Debug.WriteLine(string.Format("Type {0} needs to implement a Value property (method {1})", method.DeclaringType.Name, method.Name));
}
}
}
return(result);
}
public static CheckDescription AnalyzeSignature(MethodBase method)
{
var result = new CheckDescription { Check = method };
if (method.IsStatic)
{
// check if this is an extension method
if (method.GetCustomAttributes(typeof(ExtensionAttribute), false).Length > 0)
{
ParameterInfo[] parameters = method.GetParameters();
ParameterInfo param = parameters[0];
Type paramType = param.ParameterType;
if (!paramType.IsGenericType)
{
// this is not an check implementation
return null;
}
if (paramType.Name != "IFluentAssertion`1" && paramType.GetInterface("IFluentAssertion`1") == null)
{
// this is not an check implementation
return null;
}
// identify type subjected to test
var testedtype = paramType.GetGenericArguments()[0];
result.CheckedType = testedtype;
// get other parameters
result.CheckParameters = new List<Type>(parameters.Length - 1);
for (int i = 1; i < parameters.Length; i++)
{
result.CheckParameters.Add(parameters[i].ParameterType);
}
}
else
{
// unexpected case: check is a static method which is not an extension method
return null;
}
}
else
{
if (method.DeclaringType == null)
{
return null;
}
// this is an instance method, tested type is part of type defintion
Type scanning = method.DeclaringType.GetInterface("IFluentAssertion`1");
if (scanning != null && scanning.IsGenericType)
{
// the type implements IFluentAssertion<T>
result.CheckedType = scanning.IsGenericType ? scanning.GetGenericArguments()[0] : null;
// get other parameters
result.CheckParameters = new List<Type>();
foreach (ParameterInfo t in method.GetParameters())
{
result.CheckParameters.Add(t.ParameterType);
}
}
else
{
// type does not implement IFluentAssertion<T>, we try to find a 'Value' property
var prop = method.DeclaringType.GetProperty("Value");
if (prop != null)
{
result.CheckedType = prop.PropertyType;
// get other parameters
result.CheckParameters = new List<Type>();
foreach (ParameterInfo t in method.GetParameters())
{
result.CheckParameters.Add(t.ParameterType);
}
}
else
{
// not a check method
Debug.WriteLine(string.Format("Type {0} needs to implement a Value property (method {1})", method.DeclaringType.Name, method.Name));
}
}
}
return result;
}