public ConventionResult IsSatisfiedBy(DatabaseSpecimen databaseSpecimen)
{
var script = GetScript();
if (string.IsNullOrWhiteSpace(script))
{
throw new InvalidOperationException("Resource identified did not contain any SQL script.");
}
var failures = new List <string>();
using (IDbConnection dbConnection = new SqlConnection(databaseSpecimen.ConnectionString))
{
dbConnection.Open();
var command = dbConnection.CreateCommand();
command.CommandText = script;
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
failures.Add(reader.GetString(0));
}
}
}
if (failures.Any())
{
return(ConventionResult.NotSatisfied(DatabaseConventionResultIdentifier,
FailureMessage + Environment.NewLine +
failures.Aggregate((x, y) => x + Environment.NewLine + y)));
}
return(ConventionResult.Satisfied(DatabaseConventionResultIdentifier));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
var assignments =
type.ToTypeDefinition()
.Methods
.Where(method => method.HasBody)
.SelectMany(method => method.Body.Instructions)
.Where(x =>
x.OpCode == OpCodes.Call && x.Operand is MethodReference)
.Join(_getterDetails,
x => new
{
DeclaringType = ((MethodReference)x.Operand).DeclaringType.FullName,
MethodName = ((MethodReference)x.Operand).Name
},
g => new
{
g.DeclaringType,
g.MethodName
},
(x, g) => x)
.ToArray();
if (assignments.Any())
{
return(ConventionResult.NotSatisfied(type.FullName, FailureMessage.FormatWith(assignments.Count(), type.FullName)));
}
return(ConventionResult.Satisfied(type.FullName));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
var query = (IDapperQuery)Activator.CreateInstance(type, _connectionFactory);
var queryParametersType = type.GetInterfaces()[0].GetGenericArguments()[0];
var queryParameters = queryParametersType.GetProperties()
.Select(x => "@" + x.Name.ToLower())
.ToArray();
var sqlParameters = Regex.Matches(query.GetSql(), @"\@[a-z]+", RegexOptions.IgnoreCase)
.Cast <Match>()
.Select(m => m.Value.ToLower())
.ToArray();
var queryParamNotInSql = queryParameters.Where(qp => !sqlParameters.Contains(qp));
var failures = queryParamNotInSql
.Select(
parameter =>
$"Query {type.FullName} Sql should specify parameter {parameter} found in Parameters Collection, but does not.")
.ToList();
var sqlParamNotInQuery = sqlParameters.Where(sqlp => !queryParameters.Contains(sqlp));
failures.AddRange(sqlParamNotInQuery.Select(
parameter =>
$"Query {type.FullName} Parameters Collection should contain parameter {parameter} found in Sql, but does not."));
return(failures.Any()
? ConventionResult.NotSatisfied(type.FullName,
failures.Aggregate(string.Empty, (s, s1) => s + s1 + Environment.NewLine))
: ConventionResult.Satisfied(type.FullName));
}
protected override ConventionResult IsSatisfiedByInternal(string assemblyName, XDocument projectDocument)
{
var references =
projectDocument.Elements()
.Single(x => x.Name.LocalName == "Project")
.Elements()
.Where(x => x.Name.LocalName == "ItemGroup")
.SelectMany(x => x.Elements().Where(e => e.Name.LocalName == "Reference"));
var failures =
references
.Where(x => x.Elements().Any(e => e.Name.LocalName == "HintPath" && Regex.IsMatch(e.Value, ObjOrBinPattern)))
.Select(x =>
new Failure(
x.Attributes().Single(a => a.Name.LocalName == "Include").Value,
x.Elements().Single(e => e.Name.LocalName == "HintPath").Value))
.ToArray();
if (failures.Any())
{
var failureText =
FailureMessage.FormatWith(assemblyName) +
Environment.NewLine +
failures.Aggregate(string.Empty,
(s, t) => s + "\t" + t.Reference + " " + "(" + t.Location + ")" + Environment.NewLine);
return(ConventionResult.NotSatisfied(assemblyName, failureText));
}
return(ConventionResult.Satisfied(assemblyName));
}
private ConventionResult NotSatisfied(Type type)
{
var format = FailureMessage + Environment.NewLine + _reason;
var message = string.Format(format, _propertyType.FullName);
return(ConventionResult.NotSatisfied(type.FullName, message));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
var constructors = type.GetConstructors(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
// Note: only one constructor? it should be public.
if (constructors.Count() == 1)
{
if (constructors.Single().IsPublic)
{
return(ConventionResult.Satisfied(type.FullName));
}
return(ConventionResult.NotSatisfied(type.FullName, FailureMessage));
}
// Note: more than one constructor? the default constructor should be protected and the others public.
var defaultConstructorIsProtected = constructors.Where(c => c.GetParameters().Any() == false).All(c => c.IsFamily);
var allNonDefaultConstructorsArePublic = constructors.Where(c => c.GetParameters().Any()).All(c => c.IsPublic);
if (defaultConstructorIsProtected && allNonDefaultConstructorsArePublic)
{
return(ConventionResult.Satisfied(type.FullName));
}
return(ConventionResult.NotSatisfied(type.FullName, FailureMessage));
}
private ConventionResult BuildResult(Document document, SyntaxNode node)
{
var result = CheckNode(node, document);
return(result.Success
? ConventionResult.Satisfied(document.FilePath)
: ConventionResult.NotSatisfied(document.FilePath, FailureMessage.FormatWith(result.Message, result.LineNumber)));
}
private ConventionResult BuildResult(Document document, SyntaxNode node)
{
var result = CheckNode(node, document);
return(result.Success
? ConventionResult.Satisfied(document.FilePath)
: ConventionResult.NotSatisfied(document.FilePath, result.Message));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
if (type.Namespace != null && type.Namespace.StartsWith(parentNamespace))
{
return(ConventionResult.Satisfied(type.FullName));
}
return(ConventionResult.NotSatisfied(type.FullName, string.Format(FailureMessage, parentNamespace, type.Namespace)));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
var query = (IDapperQuery)Activator.CreateInstance(type, _connectionFactory);
return(query.GetSql().Contains("*")
? ConventionResult.NotSatisfied(type.FullName, FailureMessage)
: ConventionResult.Satisfied(type.FullName));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
if (type.Name.EndsWith(_suffix) == false)
{
return(ConventionResult.NotSatisfied(type.FullName, FailureMessage.FormatWith(type.FullName)));
}
return(ConventionResult.Satisfied(type.FullName));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
if (type.IsPublic)
{
return(ConventionResult.NotSatisfied(type.FullName, FailureMessage));
}
return(ConventionResult.Satisfied(type.FullName));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
if (type.Namespace == null || type.Namespace.Equals(_nameSpace) == false)
{
return(ConventionResult.NotSatisfied(type.FullName, FailureMessage.FormatWith(_nameSpace, type.Namespace)));
}
return(ConventionResult.Satisfied(type.FullName));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
if (type.GetConstructors().SelectMany(x => x.GetParameters()).Any(x => x.ParameterType == _dependencyType))
{
return(ConventionResult.NotSatisfied(type.FullName, FailureMessage.FormatWith(_dependencyType.FullName)));
}
return(ConventionResult.Satisfied(type.FullName));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
if (type.GetCustomAttributes(_attributeType, false).Any() == false)
{
return(ConventionResult.NotSatisfied(type.FullName, FailureMessage.FormatWith(_attributeType.FullName)));
}
return(ConventionResult.Satisfied(type.FullName));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
var isSatisfied = _predicate.Invoke(type.Namespace);
if (isSatisfied)
{
return(ConventionResult.Satisfied(type.FullName));
}
return(ConventionResult.NotSatisfied(type.FullName, FailureMessage));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
if (_subjects
.Where(x => x.BaseType != null && x.BaseType.IsGenericType)
.Any(x => _required.GetGenericTypeDefinition() == x.BaseType.GetGenericTypeDefinition() && x.BaseType.GetGenericArguments().Any(g => g == type)))
{
return(ConventionResult.Satisfied(type.FullName));
}
return(ConventionResult.NotSatisfied(type.FullName, FailureMessage.FormatWith(_required.FullName)));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
var name = type.Name;
if (type.IsGenericType)
{
name = name.Substring(0, name.IndexOf("`", StringComparison.Ordinal));
}
return(name.EndsWith(_suffix) == false
? ConventionResult.NotSatisfied(type.FullName, FailureMessage.FormatWith(_suffix))
: ConventionResult.Satisfied(type.FullName));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
var name = _resourceNameMatcher(type);
using (var manifestResourceStream = type.Assembly.GetManifestResourceStream(name))
{
if (manifestResourceStream == null)
{
return(ConventionResult.NotSatisfied(type.FullName, FailureMessage.FormatWith(type.FullName, name)));
}
}
return(ConventionResult.Satisfied(type.FullName));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
var constructors = type.GetConstructors(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
var anyConstructorsUsingMel = constructors
.SelectMany(c => c.GetParameters())
.Any(c =>
c.ParameterType == typeof(ILogger) ||
(c.ParameterType.IsGenericType && c.ParameterType.GetGenericTypeDefinition() == typeof(ILogger <>))
);
return(anyConstructorsUsingMel ? ConventionResult.NotSatisfied(type.FullName, FailureMessage) : ConventionResult.Satisfied(type.FullName));
}
private ConventionResult BuildResult(string assemblyName, string[] failures)
{
if (failures.Any())
{
var failureText = FailureMessage.FormatWith(_friendlyDescription, assemblyName) +
Environment.NewLine +
string.Join(Environment.NewLine, failures.Select(x => "- " + x));
return(ConventionResult.NotSatisfied(assemblyName, failureText));
}
return(ConventionResult.Satisfied(assemblyName));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
var defaultConstructor = type
.GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance)
.FirstOrDefault(c => c.GetParameters().Any() == false);
if (defaultConstructor == null)
{
return(ConventionResult.NotSatisfied(type.FullName, FailureMessage));
}
return(ConventionResult.Satisfied(type.FullName));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
var isSettingsType = (type.InheritsFrom(typeof(ConfigurationSetting <>)) ||
type.GetInterfaces().Any(t => t == typeof(IComplexConfigurationSetting)));
if (isSettingsType)
{
return(type.Name.EndsWith("Setting")
? ConventionResult.Satisfied(type.FullName)
: ConventionResult.NotSatisfied(type.FullName, FailureMessage));
}
return(ConventionResult.Satisfied(type.FullName));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
var resourceName = type.FullName + _extension;
using (var stream = type.Assembly.GetManifestResourceStream(resourceName))
{
if (stream == null)
{
return(ConventionResult.NotSatisfied(type.FullName, FailureMessage.FormatWith(type.FullName, resourceName)));
}
}
return(ConventionResult.Satisfied(type.FullName));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
var typeDefinition = type.ToTypeDefinition();
var subjects = typeDefinition.Properties;
var subjectPropertySetters = subjects
.Where(p => p.SetMethod != null)
.Select(p => p.SetMethod.Name)
.ToArray();
var constructors =
typeDefinition
.GetConstructors()
.Where(c => c.Parameters.Any() && c.IsStatic == false)
.ToArray();
if (constructors.Count() > 1)
{
return(ConventionResult.NotSatisfied(type.FullName, FailureMessage + " - could not determine method of construction due to more than one parameterized constructor existing"));
}
var constructor = constructors.SingleOrDefault();
if (constructor == null)
{
return(_ignoreTypesWithoutConstructors ? ConventionResult.Satisfied(type.FullName) : ConventionResult.NotSatisfied(type.FullName, FailureMessage + " - could not enforce method of construction due to no parameterized constructor existing"));
}
var setters =
constructor
.Body
.Instructions
.Select(i => i.Operand)
.OfType <MethodDefinition>()
.Select(m => m.Name)
.ToArray();
if (subjectPropertySetters.All(setters.Contains))
{
return(ConventionResult.Satisfied(type.FullName));
}
var failureMessage =
BuildFailureMessage(subjectPropertySetters.Where(x => setters.Contains(x) == false).Aggregate(string.Empty,
(s, name) => s + "\t- " + name + Environment.NewLine));
return(ConventionResult.NotSatisfied(type.FullName, failureMessage));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
var enumerables = GetProperties(type);
var failures = enumerables.Where(x => x.GetSetMethod() != null).ToArray();
if (failures.Any())
{
return(ConventionResult.NotSatisfied(type.FullName,
BuildFailureMessage(failures.Aggregate(string.Empty,
(s, t) => s + "\t" + type.FullName + Environment.NewLine))));
}
return(ConventionResult.Satisfied(type.FullName));
}
private static ConventionResult CompareEnums(IDictionary <int, string> left, IDictionary <int, string> right, ConventionResult result)
{
foreach (var leftValue in left)
{
if (!right.ContainsKey(leftValue.Key))
{
result = result.And(ConventionResult.NotSatisfied(leftValue.Value, string.Format("{0} ({1}) does not match any values", leftValue.Value, leftValue.Key)));
}
else if (right[leftValue.Key] != leftValue.Value)
{
result = result.And(ConventionResult.NotSatisfied(leftValue.Value, string.Format("{0} ({1}) does not match names with the corresponding value", leftValue.Value, leftValue.Key)));
}
}
return(result);
}
public override ConventionResult IsSatisfiedBy(Type type)
{
var failures = GetNonConformingProperties(type);
if (failures.Any())
{
var failureMessage =
BuildFailureMessage(failures.Aggregate(string.Empty,
(s, info) => s + "\t- " + info.Name + Environment.NewLine));
return(ConventionResult.NotSatisfied(type.FullName, failureMessage));
}
return(ConventionResult.Satisfied(type.FullName));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
var failures = GetMethods(type).Where(method => !IsSatisfiedBy(method)).ToList();
if (failures.Any())
{
var details = failures.Aggregate(string.Empty, (s, method) =>
$"{s}\t- {FullMethodName(method)}{Environment.NewLine}");
var failureMessage = BuildFailureMessage(details);
return(ConventionResult.NotSatisfied(type.FullName, failureMessage));
}
return(ConventionResult.Satisfied(type.FullName));
}
public override ConventionResult IsSatisfiedBy(Type type)
{
var toInspect = type.GetMethods().Where(m => m.ReturnType == typeof(void));
var failures = toInspect.Where(HasAttribute <AsyncStateMachineAttribute>);
if (failures.Any())
{
var details = failures.Aggregate(string.Empty, (s, info) => s + "\t- " + info.Name + Environment.NewLine);
var failureMessage = BuildFailureMessage(details);
return(ConventionResult.NotSatisfied(type.FullName, failureMessage));
}
return(ConventionResult.Satisfied(type.FullName));
}
