public void Execute(Types data, IConventionResultContext result)
{
result.Is("Each type must have at most one constructor",
data.TypesToVerify.Select(SmartType.For)
.Where(t => !t.IsException())
.Where(t => !t.HasPublicConstructorCountOfAtMost(1))
.Select(t => t.ToClrType()));
}
public void Execute(Types data, IConventionResultContext result)
{
result.IsSymmetric(
string.Format("{0}s must be under the '{1}' namespace", classType, namespaceToCheck),
string.Format("Non-{0}s must not be under the '{1}' namespace", classType, namespaceToCheck),
classIsApplicable,
TypeLivesInSpecifiedNamespace,
data.TypesToVerify.Where(t => !t.IsCompilerGenerated()));
}
public void Execute(Types data, IConventionResultContext result)
{
var notifyPropertyChanged = typeof(INotifyPropertyChanged);
var failingData = data.TypesToVerify.Where(t => t.Name.EndsWith(viewModelSuffix, StringComparison.OrdinalIgnoreCase))
.Where(t => !notifyPropertyChanged.GetTypeInfo().IsAssignableFrom(t.GetTypeInfo()));
result.Is($"ViewModels (types named *{viewModelSuffix}) should inherit from INotifyPropertyChanged",
failingData);
}
public void Execute(Types data, IConventionResultContext result)
{
var notifyPropertyChanged = typeof(INotifyPropertyChanged);
var failingData = data.TypesToVerify.Where(t => t.Name.EndsWith(viewModelSuffix, StringComparison.InvariantCultureIgnoreCase))
.Where(t => !notifyPropertyChanged.IsAssignableFrom(t));
result.Is(string.Format("ViewModels (types named *{0}) should inherit from INotifyPropertyChanged", viewModelSuffix),
failingData);
}
public void Execute(Types data, IConventionResultContext result)
{
result.IsSymmetric(
"All types inheriting from exception must end with 'Exception'",
data
.Where(t => t.IsSubclassOf(typeof(Exception)))
.Where(t => !t.Name.EndsWith("Exception")),
"All types ending with 'Exception' must inherit from Exception",
data
.Where(t => t.Name.EndsWith("Exception"))
.Where(t => !t.IsSubclassOf(typeof(Exception))));
}
public void Execute(ProjectPropertyGroups data, IConventionResultContext result)
{
foreach (var group in data.PropertyGroups.Where(Match))
{
if (group[Property] == null)
{
continue;
}
result.Is(string.Format("{0} property in {1} must have a value of {2}", this.Property, group.Name, this.Value),
group[Property].Equals(this.Value) ? new string[] {} : new[] { string.Format("{0}:{1}", this.Property, group[Property]) });
}
}
public void Execute(Types data, IConventionResultContext result)
{
var controllers = GetControllers(data);
var typesWhichDoNotEndInController = controllers.Where(c => !c.Name.EndsWith("Controller"));
var typesWhichEndInController = data.TypesToVerify.Where(t => t.Name.EndsWith("Controller"));
var controllersWhichDoNotInheritFromController =
typesWhichEndInController.Where(t => !IsMvcController(t) && !IsWebApiController(t));
result.IsSymmetric(
GetControllerTypeName() + "s must be suffixed with Controller", typesWhichDoNotEndInController,
"Types named *Controller must inherit from ApiController or Controller",
controllersWhichDoNotInheritFromController);
}
public void Execute(Types data, IConventionResultContext result)
{
var failingTypes =
from shouldlyClasses in data
from shouldlyMethods in shouldlyClasses.GetMethods()
where typeof(object).GetMethods().All(m => m.Name != shouldlyMethods.Name)
group shouldlyMethods by FormatKey(shouldlyMethods) into shouldlyMethod
where HasNoCustomMessageOverload(shouldlyMethod)
select shouldlyMethod.Key;
result.Is(
"The following shouldly methods are missing one or more of the custom message overloads",
failingTypes);
}
public void Execute(Types data, IConventionResultContext result)
{
ConventionTitle = "well, does the header apply here all across the board? How would that work for CSV?";
var types = data.TypesToVerify;
var collectionToItemLookup = from collection in types
where collection.IsClass
orderby collection.FullName
from item in GetItemTypes(collection)
select new
{
collection,
item,
can_add = typeof(ICanAdd <>).MakeGenericType(item).IsAssignableFrom(collection),
can_remove = typeof(ICanRemove <>).MakeGenericType(item).IsAssignableFrom(collection)
};
result.Is("Some title", collectionToItemLookup);
}
public void Execute(Types data, IConventionResultContext result)
{
var shouldThrowMethods = data
.SelectMany(t => t.GetMethods())
.Where(method => method.Name.StartsWith("Throw") || method.Name.StartsWith("ShouldThrow"))
.Select(throwMethod => new ShouldThrowMethod(throwMethod))
.ToList();
var extensionMethods = shouldThrowMethods.Where(m => m.IsShouldlyExtension).ToList();
var staticMethods = shouldThrowMethods.Where(m => !m.IsShouldlyExtension).ToList();
var firstSetFailureData = staticMethods.Where(e => !extensionMethods.Any(e.Equals));
var secondSetFailureData = extensionMethods.Where(e => !staticMethods.Any(e.Equals));
result.IsSymmetric(
"Should.Throw method without corresponding ShouldThrow extension method",
firstSetFailureData,
"ShouldThrow extension method without Should.Throw static method",
secondSetFailureData);
}
public void Execute(Types data, IConventionResultContext result)
{
var resultProperty = typeof(ConfigInitWizardStep).GetProperty("DefaultResult", BindingFlags.NonPublic | BindingFlags.Instance);
result
.Is("Init steps default response should not throw",
data.TypesToVerify.Where(t =>
{
var constructorInfo = t.GetConstructors().Single();
var ctorArguments = constructorInfo.GetParameters().Select(p => p.ParameterType.IsValueType ? Activator.CreateInstance(p.ParameterType) : null).ToArray();
var instance = Activator.CreateInstance(t, ctorArguments);
try
{
resultProperty.GetValue(instance);
}
catch (Exception)
{
return(true);
}
return(false);
}));
}
public void Execute(AutofacRegistrations data, IConventionResultContext result)
{
var distinctTypes = data.ComponentRegistry.Registrations
.SelectMany(r => r.Services.OfType <TypedService>().Select(s => s.ServiceType).Union(GetGenericFactoryTypes(data, r)))
.Distinct();
var failingTypes = new List <string>();
foreach (var distinctType in distinctTypes)
{
try
{
container.Resolve(distinctType);
}
catch (DependencyResolutionException e)
{
failingTypes.Add(e.Message);
}
}
result.Is("Can resolve all types registered with Autofac", failingTypes);
}
public void Execute(AutofacRegistrations data, IConventionResultContext result)
{
var exceptions = new List <string>();
foreach (var registration in data.ComponentRegistry.Registrations)
{
var registrationLifetime = data.GetLifetime(registration);
foreach (var ctorParameter in data.GetRegistrationCtorParameters(registration))
{
IComponentRegistration parameterRegistration;
var typedService = new TypedService(ctorParameter.ParameterType);
// If the parameter is not registered with autofac, ignore
if (!data.ComponentRegistry.TryGetRegistration(typedService, out parameterRegistration))
{
continue;
}
var parameterLifetime = data.GetLifetime(parameterRegistration);
if (parameterLifetime >= registrationLifetime)
{
continue;
}
var typeName = data.GetConcreteType(registration).ToTypeNameString();
var parameterType = ctorParameter.ParameterType.ToTypeNameString();
var error = string.Format("{0} ({1}) => {2} ({3})",
typeName, registrationLifetime,
parameterType, parameterLifetime);
exceptions.Add(error);
}
}
result.Is("Components should not depend on services with lesser lifetimes", exceptions);
}
public void Execute(Types data, IConventionResultContext result)
{
var invalidTypes = data.TypesToVerify.Where(type => !type.IsAbstract).ToList();
result.Is("Types should be abstract", invalidTypes);
}
public void Execute(Types data, IConventionResultContext result)
{
var failingTypes = data.TypesToVerify.Where(IsBroken);
// Oops, I forgot to set the result
}
public void Execute(Types data, IConventionResultContext result)
{
result.Is("Methods must be virtual", data.TypesToVerify.SelectMany(t => t.NonVirtualMethods()));
}
public void Execute(Types data, IConventionResultContext result)
{
result.Is("Types must have a default constructor",
data.TypesToVerify.Where(t => t.HasDefaultConstructor() == false));
}
public void Execute(ProjectFileItems data, IConventionResultContext result)
{
result.Is(
string.Format("{0} Files must be embedded resources", FileExtension),
data.Items.Where(s => s.FilePath.EndsWith(FileExtension) && s.ReferenceType != "EmbeddedResource"));
}
public void Execute(ProjectReferences data, IConventionResultContext result)
{
result.Is("Project must not reference dlls from bin or obj directories",
data.References.Where(IsBinOrObjReference));
}
public void Execute(Assemblies assemblies, IConventionResultContext result)
{
result.Is($"Forbidden reference to {_forbiddenReference}"
+ Because()
, assemblies.Referencing(_forbiddenReference));
}
