public void InternalAttributesAreIgnored()
{
var context = ClassContextObjectMother.Create(typeof(ClassWithInternalAttribute));
var definition = TargetClassDefinitionFactory.CreateAndValidate(context);
Assert.That(definition.CustomAttributes.ContainsKey(typeof(InternalStuffAttribute)), Is.False);
}
/// <summary>
/// Validates the whole configuration.
/// </summary>
/// <returns>An <see cref="ValidationLogData"/> object, which contains information about whether the configuration reresented by this context is valid.</returns>
/// <remarks>This method retrieves definition items for all the <see cref="ClassContexts"/> known by this configuration and uses the
/// <see cref="Validator"/> class to validate them. The validation results can be inspected, passed to a <see cref="ValidationException"/>, or
/// be dumped using the <see cref="T:Remotion.Development.Mixins.Validation.ConsoleDumper"/>.</remarks>
/// <exception cref="NotSupportedException">The <see cref="MixinConfiguration"/> contains a <see cref="ClassContext"/> for a generic type, of
/// which it cannot make a closed generic type. Because closed types are needed for validation, this <see cref="MixinConfiguration"/>
/// cannot be validated as a whole. Even in this case, the configuration might still be correct, but validation is deferred to
/// <see cref="TargetClassDefinitionFactory.CreateAndValidate"/>.</exception>
public ValidationLogData Validate()
{
var definitions = from classContext in ClassContexts
where !classContext.Type.IsGenericTypeDefinition && !classContext.Type.IsInterface
select(IVisitableDefinition) TargetClassDefinitionFactory.CreateWithoutValidation(classContext);
return(Validator.Validate(definitions));
}
public void CreateTargetClassDefinition_ReturnsValidClassDefinition()
{
var context = ClassContextObjectMother.Create(typeof(BaseType1));
var def = TargetClassDefinitionFactory.CreateAndValidate(context);
Assert.That(def, Is.Not.Null);
Assert.That(def.ConfigurationContext, Is.SameAs(context));
}
public TargetClassDefinition GetTargetClassDefinition(ClassContext classContext)
{
if (classContext == null)
{
return(null);
}
return(TargetClassDefinitionFactory.CreateAndValidate(classContext));
}
public void FailsIfInterfaceMixinDependencyNotFulfilled()
{
ClassContext context = new ClassContextBuilder(typeof(TargetClassWithAdditionalDependencies)).AddMixin <MixinWithAdditionalInterfaceDependency> ().WithDependency <IMixinWithAdditionalClassDependency> ().BuildClassContext();
TargetClassDefinition definition = TargetClassDefinitionFactory.CreateWithoutValidation(context);
var log = Validator.Validate(definition.Mixins[typeof(MixinWithAdditionalInterfaceDependency)]);
Assert.That(HasFailure("Remotion.Mixins.Validation.Rules.DefaultMixinDependencyRules.DependencyMustBeSatisfiedByAnotherMixin", log), Is.True);
}
public static TargetClassDefinition BuildUnvalidatedDefinition(Type baseType, params Type[] mixinTypes)
{
ArgumentUtility.CheckNotNull("baseType", baseType);
ArgumentUtility.CheckNotNull("mixinTypes", mixinTypes);
var context = ClassContextObjectMother.Create(baseType, mixinTypes);
return(TargetClassDefinitionFactory.CreateWithoutValidation(context));
}
public static TargetClassDefinition GetActiveTargetClassDefinition(Type type)
{
ArgumentUtility.CheckNotNull("type", type);
var classContext = MixinConfiguration.ActiveConfiguration.GetContext(type);
Assert.That(classContext, Is.Not.Null, "The given type '" + type.Name + "' must be configured as a mixin target.");
return(TargetClassDefinitionFactory.CreateAndValidate(classContext));
}
public void SetUp()
{
_remotionReflector = new Reflectors.Net4_5SupportReflector().Initialize(".");
var mixinConfiguration = MixinConfiguration.BuildNew()
.ForClass <TargetClass1> ()
.AddMixin <Mixin1> ()
.BuildConfiguration();
_targetClassDefinition = TargetClassDefinitionFactory.CreateAndValidate(mixinConfiguration.ClassContexts.First());
_mixinDefinition = _targetClassDefinition.GetMixinByConfiguredType(typeof(Mixin1));
}
public void SetUp()
{
_remotionReflector = new Reflectors.NewMixinDependenciesReflector();
var mixinConfiguration = MixinConfiguration.BuildNew()
.ForClass <TargetClass1> ()
.AddMixin <Mixin1> ()
.BuildConfiguration();
_targetClassDefinition = TargetClassDefinitionFactory.CreateTargetClassDefinition(mixinConfiguration.ClassContexts.First());
_mixinDefinition = _targetClassDefinition.GetMixinByConfiguredType(typeof(Mixin1));
}
public void GetTargetClassDefinition()
{
var mixinConfiguration = MixinConfiguration.BuildNew()
.ForClass <TargetClass1> ().AddMixin <Mixin1> ()
.BuildConfiguration();
var reflectedOutput = _remotionReflector.GetTargetClassDefinition(typeof(TargetClass1), new ReflectedObject(mixinConfiguration), new ReflectedObject(mixinConfiguration.ClassContexts.GetWithInheritance(typeof(TargetClass1))));
var expectedOutput = TargetClassDefinitionFactory.CreateTargetClassDefinition(mixinConfiguration.ClassContexts.First());
Assert.That(reflectedOutput.To <TargetClassDefinition> (), Is.InstanceOf(typeof(TargetClassDefinition)));
Assert.That(reflectedOutput.To <TargetClassDefinition> ().FullName, Is.EqualTo(expectedOutput.FullName));
}
private static ConcreteMixinType GetGeneratedMixinTypeAndMetadata(ClassContext requestingClass, Type mixinType)
{
MixinDefinition mixinDefinition = TargetClassDefinitionFactory
.CreateAndValidate(requestingClass)
.GetMixinByConfiguredType(mixinType);
Assert.That(mixinDefinition, Is.Not.Null);
var mixinTypeIdentifier = mixinDefinition.GetConcreteMixinTypeIdentifier();
var pipeline = SafeServiceLocator.Current.GetInstance <IPipelineRegistry>().DefaultPipeline;
var generatedMixinType = pipeline.ReflectionService.GetAdditionalType(mixinTypeIdentifier);
return(new AttributeBasedMetadataImporter().GetMetadataForMixinType(generatedMixinType));
}
public void ReMotionApiUsages()
{
DeclarativeConfigurationBuilder.BuildConfigurationFromAssemblies(new Assembly[0]);
TargetClassDefinitionFactory.CreateAndValidate(null);
LogManager.GetLogger("");
Use(new NonApplicationAssemblyAttribute());
Use(new ConfigurationException(""));
Use(new ValidationException(new ValidationLogData()));
Use(typeof(IInitializableMixin));
Use <TargetClassDefinition> (_ => _.GetMixinByConfiguredType(typeof(object)));
Use <TargetClassDefinition> (_ => _.GetAllMembers());
Use <TargetClassDefinition> (_ => _.ImplementedInterfaces);
Use <TargetClassDefinition> (_ => _.ReceivedInterfaces);
Use <ClassContext> (_ => _.ComposedInterfaces);
Use <ClassContext> (_ => _.Mixins);
Use <MixinDefinition> (_ => _.NextCallDependencies);
Use <MixinDefinition> (_ => _.TargetCallDependencies);
Use <MixinDefinition> (_ => _.GetAllOverrides());
Use <MixinDefinition> (_ => _.AcceptsAlphabeticOrdering);
Use <MixinDefinition> (_ => _.MixinIndex);
Use <MixinDefinition> (_ => _.InterfaceIntroductions);
Use <MixinDefinition> (_ => _.AttributeIntroductions);
Use <MixinDefinition> (_ => _.TargetClass);
Use <MixinContext> (_ => _.MixinType);
Use <MixinContext> (_ => _.ExplicitDependencies);
Use <MixinContext> (_ => _.MixinKind);
Use <MixinConfiguration> (_ => _.ClassContexts);
Use <ClassContextCollection> (_ => _.GetWithInheritance(typeof(object)));
Use <ValidationException> (_ => _.Data); //TODO: add validationLogData from re-motion 1.15.6
Use <AttributeIntroductionDefinition> (_ => _.AttributeType);
Use <InterfaceIntroductionDefinition> (_ => _.InterfaceType);
Use <MemberDefinitionBase> (_ => _.MemberType);
Use <MemberDefinitionBase> (_ => _.Name);
Use <MemberDefinitionBase> (_ => _.MemberInfo);
Use <MemberDefinitionBase> (_ => _.BaseAsMember);
Use <MemberDefinitionBase> (_ => _.Overrides);
Use <MemberDefinitionBase> (_ => _.DeclaringClass);
Use <ClassDefinitionBase> (_ => _.Type);
Use <TargetCallDependencyDefinition> (_ => _.RequiredType);
Use <RequiredTargetCallTypeDefinition> (_ => _.Type);
//TODO: add SerializableValidationLogData members
}
public void CreateTargetClassDefinition_ValidatesWhenGeneratingDefinition()
{
var cc = ClassContextObjectMother.Create(typeof(DateTime));
TargetClassDefinitionFactory.CreateAndValidate(cc);
}
public static TargetClassDefinition GetTargetClassDefinition(ClassContext classContext)
{
ArgumentUtility.CheckNotNull("classContext", classContext);
return(TargetClassDefinitionFactory.CreateAndValidate(classContext));
}
