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 TypeFieldConventionContext(IEngineConfiguration config, IEngineConfigurationTypeMember member)
: base(config, member)
{
}
public TypeMemberConventionContext(IEngineConfiguration configuration, IEngineConfigurationTypeMember member)
{
mConfiguration = configuration;
mTypeMember = member;
}
private void ApplyToTypeMember(IEngineConfigurationTypeMember member)
{
if (member.Member.IsField)
{
ApplyFieldConventions(member);
}
if (member.Member.IsProperty)
{
ApplyPropertyConventions(member);
}
}
public void MethodWithLiteralArgument_HasOneDatasource()
{
IEngineConfigurationTypeMember member = mEngineConfigurationType.GetRegisteredMember(mSingleArgMethod);
Assert.AreEqual(1, member.GetDatasources().Count());
}
