public void MethodWithTwoArguments_HasCorrectDatasource(int skip, Type expectedType) { IEngineConfigurationTypeMember member = mEngineConfigurationType.GetRegisteredMember(mDoubleArgMethod); IEngineConfigurationDatasource sourceConfig = member.GetDatasources().Skip(skip).First(); IDatasource source = sourceConfig.Build(); Assert.AreEqual(expectedType, source.GetType()); }
public void MethodWithLiteralArgument_HasValueDatasource() { IEngineConfigurationTypeMember member = mEngineConfigurationType.GetRegisteredMember(mSingleArgMethod); IEngineConfigurationDatasource configurationSource = member.GetDatasources().Single(); IDatasource source = configurationSource.Build(); Assert.AreEqual(typeof(ValueSource <object>), source.GetType()); }
private void ApplyToTypeMember(IEngineConfigurationTypeMember member) { if (member.Member.IsField) { ApplyFieldConventions(member); } if (member.Member.IsProperty) { ApplyPropertyConventions(member); } }
public void Setup() { this.Builder.Conventions(x => { x.Register <TestFieldConvention>(); }); this.Builder.Include <TestFieldClass>() .Setup(x => x.Test).Default() .Setup(x => x.TestIgnore); mConfiguration = new EngineConfigurationFactory().Create(this.Builder, this.Builder.ConventionProvider); mType = mConfiguration.GetRegisteredType(typeof(TestFieldClass)); mTestField = mType.GetRegisteredMembers().Where(x => x.Member.Name == "Test").Single(); mTestIgnoreField = mType.GetRegisteredMembers().Where(x => x.Member.Name == "TestIgnore").Single(); }
protected virtual void ApplyBaseRulesToType(IEngineConfigurationProviderLoaderContext context, IEngineConfigurationType type) { IEnumerable <IEngineConfigurationTypeMember> membersToApply = GetAllTypeHierarchyMembers(context.Configuration, type); foreach (var existingMemberConfig in membersToApply) { IEngineConfigurationTypeMember currentMemberConfig = type.GetRegisteredMember(existingMemberConfig.Member); if (currentMemberConfig == null) { type.RegisterMember(existingMemberConfig.Member); currentMemberConfig = type.GetRegisteredMember(existingMemberConfig.Member); currentMemberConfig.SetDatasources(existingMemberConfig.GetDatasources()); } } }
public void Setup() { this.Builder.Conventions(x => { x.Register<TestPropertyConvention>(); }); this.Builder.Include<TestPropertyClass>() .Setup(x => x.Test).Default() .Setup(x => x.TestIgnore); mConfiguration = new EngineConfigurationFactory().Create(this.Builder, this.Builder.ConventionProvider); mType = mConfiguration.GetRegisteredType(typeof(TestPropertyClass)); mTestProperty = mType.GetRegisteredMembers().Where(x => x.Member.Name == "Test").Single(); mTestIgnoreProperty = mType.GetRegisteredMembers().Where(x => x.Member.Name == "TestIgnore").Single(); }
private void ApplyToType(IEngineConfigurationType type) { // Create the dependency stack IEnumerable <IEngineConfigurationTypeMember> membersToApply = GetAllTypeHierarchyMembers(mConfiguration, type); foreach (var existingMemberConfig in membersToApply) { IEngineConfigurationTypeMember currentMemberConfig = type.GetRegisteredMember(existingMemberConfig.Member); if (currentMemberConfig == null) { type.RegisterMember(existingMemberConfig.Member); currentMemberConfig = type.GetRegisteredMember(existingMemberConfig.Member); currentMemberConfig.SetDatasources(existingMemberConfig.GetDatasources()); } } }
private void ApplyFieldConventions(IEngineConfigurationTypeMember member) { var convention = mConventionProvider.Find <ITypeFieldConvention>() .Select(t => { var details = new { Convention = (ITypeFieldConvention)Activator.CreateInstance(t), Requirements = new TypeFieldConventionRequirements() }; details.Convention.SpecifyRequirements(details.Requirements); return(details); }) .Where(x => x.Requirements.IsValid((EngineTypeFieldMember)member.Member)) .OrderByDescending(x => ScoreRequirements(x.Requirements)) .FirstOrDefault(); if (convention != null) { convention.Convention.Apply(new TypeFieldConventionContext(mConfiguration, member)); } }
private void ApplyPropertyConventions(IEngineConfigurationTypeMember member) { var convention = mConventionProvider.Find<ITypePropertyConvention>() .Select(t => { var details = new { Convention = (ITypePropertyConvention) Activator.CreateInstance(t), Requirements = new TypePropertyConventionRequirements() }; details.Convention.SpecifyRequirements(details.Requirements); return details; }) .Where(x => x.Requirements.IsValid((EngineTypePropertyMember) member.Member)) .OrderByDescending(x => ScoreRequirements(x.Requirements)) .FirstOrDefault(); if (convention != null) { convention.Convention.Apply(new TypePropertyConventionContext(mConfiguration, member)); } }
public TypeFieldConventionContext(IEngineConfiguration config, IEngineConfigurationTypeMember member) : base(config, member) { }
public void MethodWithTwoArguments_HasOneTwosources() { IEngineConfigurationTypeMember member = mEngineConfigurationType.GetRegisteredMember(mDoubleArgMethod); Assert.AreEqual(2, member.GetDatasources().Count()); }
public void MethodWithDatasourceArgument_ExposedInConfiguration() { IEngineConfigurationTypeMember member = mEngineConfigurationType.GetRegisteredMember(mDoubleArgMethod); Assert.NotNull(member); }
public void MethodWithLiteralArgument_ExposedInConfiguration() { IEngineConfigurationTypeMember member = mEngineConfigurationType.GetRegisteredMember(mSingleArgMethod); Assert.NotNull(member); }
public TypeMemberConventionContext(IEngineConfiguration configuration, IEngineConfigurationTypeMember member) { mConfiguration = configuration; mTypeMember = member; }
public void MethodWithLiteralArgument_HasOneDatasource() { IEngineConfigurationTypeMember member = mEngineConfigurationType.GetRegisteredMember(mSingleArgMethod); Assert.AreEqual(1, member.GetDatasources().Count()); }