public void debug_configurations_should_have_optimize_false()
{
var configurationHasSpecificValue = new ConfigurationHasSpecificValue(ConfigurationType.Debug, "Optimize", "false");
var projectPropertyGroups = new ProjectPropertyGroups(projectLocation);
Convention.Is(configurationHasSpecificValue, projectPropertyGroups);
}
public void release_configurations_should_have_optimize_true()
{
var configurationHasSpecificValue = new ConfigurationHasSpecificValue(ConfigurationType.Release, "Optimize", "true");
var projectPropertyGroups = new ProjectPropertyGroups(projectLocation);
Convention.Is(configurationHasSpecificValue, projectPropertyGroups);
}
public void release_configurations_should_have_debug_type_pdb_only()
{
var configurationHasSpecificValue = new ConfigurationHasSpecificValue(ConfigurationType.Release, "DebugType", "pdbonly");
var projectPropertyGroups = new ProjectPropertyGroups(projectLocation);
Convention.Is(configurationHasSpecificValue, projectPropertyGroups);
}
public void TogglesAreAbstract()
{
//var typesToCheck = Types.InAssemblyOf<SimpleFeatureToggle>("Toggle base classes", types => types.Where(x => x.Namespace == TogglesNamespace));
var typesToCheck = Types.InAssemblyOf <SimpleFeatureToggle>("Toggle base classes", type => type.Namespace == TogglesNamespace);
Convention.Is(new TypeIsAbstractConvention(), typesToCheck);
}
public void ShouldPassWhenPassedAnAssemlyToWhichSourceHasNoReference()
{
var forbiddenAssemblyReference = new AssemblyDoesNotContainForbiddenReferences(
typeof(TestAttribute).Assembly, "--REASON--");
Convention.Is(forbiddenAssemblyReference,
new Assemblies(typeof(AssemblyIdType).Assembly));
}
public void ShouldPassWhenPassedAnAssemlyToWhichSourceHasNoReference()
{
var types = Types.InAssemblyOf(typeof(AssemblyIdType))
.Without(typeof(FixtureObjectWithTwoConstructors));
var forbiddenAssemblyReference = new AllClassesHaveAtMostOneConstructor();
//WHEN-THEN
Convention.Is(forbiddenAssemblyReference, types);
}
public void TogglesInCorrectNamespace()
{
var typesToCheck = Types.InAssemblyOf <SimpleFeatureToggle>();
Convention.Is(new ClassTypeHasSpecificNamespace(
x => x.Name.EndsWith("Toggle"),
TogglesNamespace,
"Toggle Base Classes"), typesToCheck);
}
public void ShouldPassWhenPassedAnAssemlyToWhichSourceHasNoReference()
{
var types = Types.InAssemblyOf <AssemblyIdType>();
types = types.Without(typeof(ExceptionWithoutExceptionSuffix));
var convention = new ExceptionsNamesMustEndWithException();
//WHEN-THEN
Convention.Is(convention, types);
}
public void VerifyItWorks()
{
var ex = Should.Throw <ConventionFailedException>(() =>
{
var convention = new ShouldlyMethodsShouldHaveCustomMessageOverload();
var types = Types.InCollection(new[] { typeof(TestWithMissingOverloads) }, "Sample");
Convention.Is(convention, types);
});
ex.Message.ShouldContain("ShouldAlsoFail");
}
public void ConventionFailsWhenContainerRegistrationCannotBeResolved()
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType <Foo>().As <IFoo>();
var container = containerBuilder.Build();
var data = new AutofacRegistrations(container.ComponentRegistry);
Assert.Throws <ConventionFailedException>(() => Convention.Is(new CanResolveAllRegisteredServices(container), data));
}
public void ConventionShouldFailForTransientInjectectedIntoSingleton()
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType <Foo>().As <IFoo>().SingleInstance();
containerBuilder.RegisterType <Bar>().As <IBar>();
var container = containerBuilder.Build();
var convention = new ServicesShouldOnlyHaveDependenciesWithLesserLifetime();
var autofacRegistrations = new AutofacRegistrations(container.ComponentRegistry);
Assert.Throws <ConventionFailedException>(() => Convention.Is(convention, autofacRegistrations));
}
public void ShouldFailWhenPassedAnAssemlyToWhichSourceHasReference()
{
var types = Types.InAssemblyOf <AssemblyIdType>();
var convention = new ExceptionsNamesMustEndWithException();
//WHEN-THEN
var exception = Assert.Throws <ConventionFailedException>(() =>
{
Convention.Is(convention, types);
});
StringAssert.StartsWith(
"'All types inheriting from exception must end with 'Exception'' for 'Types in ConventionsFixture'",
exception.Message);
StringAssert.EndsWith("ConventionsFixture.ExceptionWithoutExceptionSuffix\r\n",
exception.Message);
Assert.AreEqual(1, OccurencesOfString("ConventionsFixture", exception.Message));
}
public void ShouldFailWhenPassedAnAssemlyToWhichSourceHasReference()
{
var types = Types.InAssemblyOf(typeof(AssemblyIdType));
var forbiddenAssemblyReference = new AllClassesHaveAtMostOneConstructor();
//WHEN-THEN
var exception = Assert.Throws <ConventionFailedException>(() =>
{
Convention.Is(forbiddenAssemblyReference, types);
});
StringAssert.StartsWith(
"'Each type must have at most one constructor' for 'Types in ConventionsFixture'",
exception.Message);
StringAssert.EndsWith("ConventionsFixture.FixtureObjectWithTwoConstructors\r\n",
exception.Message);
Assert.AreEqual(1, OccurencesOfString("ConventionsFixture", exception.Message));
}
public void ShouldFailWhenPassedAnAssemlyToWhichSourceHasReference()
{
var sourceAssembly = typeof(AssemblyIdType).Assembly;
var assemblies = new Assemblies(sourceAssembly);
var forbiddenReference = typeof(string).Assembly;
var reason = Any.String();
var expectedMessageStart = ExpectedAssemblyRefConventionMessage.Start(forbiddenReference, sourceAssembly, reason);
var expectedMessageEnd = ExpectedAssemblyRefConventionMessage.End(sourceAssembly);
var forbiddenAssemblyReference = new AssemblyDoesNotContainForbiddenReferences(
forbiddenReference, reason);
//WHEN-THEN
var exception = Assert.Throws <ConventionFailedException>(() =>
{
Convention.Is(forbiddenAssemblyReference, assemblies);
});
StringAssert.StartsWith(expectedMessageStart, exception.Message);
StringAssert.EndsWith(expectedMessageEnd, exception.Message);
}
public void DomainClassesShouldHaveVirtualProperties()
{
Convention.Is(new AllMethodsAreVirtual(), domainEntities);
}
public void MvcControllerTest()
{
Convention.Is(new MvcControllerNameAndBaseClassConvention(), Types.InAssemblyOf <TestController>());
}
public void ShouldThrowWhenConventionDoesNotSetResult()
{
Assert.Throws <ResultNotSetException>(() =>
Convention.Is(new CustomConventionWhichDoesNothing(), Types.InAssemblyOf <ConventionFixture>()));
}
public void ViewModelCOnventions()
{
Convention.Is(new ViewModelShouldInheritFromINotifyPropertyChanged(), Types.InAssemblyOf <ViewModelBase>());
}
public void ShouldThrowMethodsShouldHaveExtensions()
{
Convention.Is(new ShouldThrowMatchesExtensionsConvention(), _shouldlyMethodClasses);
}
public void WebApiConventions()
{
Convention.Is(new ApiControllerNamingAndBaseClassConvention(), Types.InAssemblyOf <TestApiController>());
}
public void ShouldHaveCustomMessageOverloads()
{
Convention.Is(new ShouldlyMethodsShouldHaveCustomMessageOverload(), _shouldlyMethodClasses);
}
public void SqlScriptsShouldBeEmbeddedResources()
{
Convention.Is(new FilesAreEmbeddedResources(".sql"), new ProjectFileItems(projectLocation));
}
public void DomainClassesShouldHaveDefaultConstructor()
{
Convention.Is(new AllClassesHaveDefaultConstructor(), domainEntities);
}
public void DefaultResponsesDoNotThrow()
{
var steps = Types.InAssemblyOf <EditConfigStep>(t => t.IsSubclassOf(typeof(ConfigInitWizardStep)) && t.IsConcreteClass());
Convention.Is(new InitStepsDefaultResponsesDoNotThrow(), steps);
}
public void DtosMustOnlyExistInDtoNameSpace()
{
Convention.Is(new ClassTypeHasSpecificNamespace(t => t.Name.EndsWith("Dto"), "SampleApp.Dtos", "Dto"),
Types.InAssemblyOf <SomeDto>());
}