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)); }