public async Task GetModelUsingDefaultModelHandler()
{
var configuration = new DomainConfiguration();
configuration.SetHookPoint(
typeof(IModelProducer), new TestModelProducer());
configuration.AddHookPoint(
typeof(IModelExtender), new TestModelExtender(2));
configuration.AddHookPoint(
typeof(IModelExtender), new TestModelExtender(3));
configuration.AddHookPoint(
typeof(IModelVisibilityFilter),
new TestModelVisibilityFilter());
configuration.EnsureCommitted();
var context = new DomainContext(configuration);
var model = await Domain.GetModelAsync(context);
Assert.Equal(3, model.SchemaElements.Count());
Assert.Null(model.SchemaElements
.SingleOrDefault(e => e.Name == "TestName"));
Assert.NotNull(model.SchemaElements
.SingleOrDefault(e => e.Name == "TestName2"));
Assert.NotNull(model.SchemaElements
.SingleOrDefault(e => e.Name == "TestName3"));
Assert.NotNull(model.EntityContainer);
Assert.Null(model.EntityContainer.Elements
.SingleOrDefault(e => e.Name == "TestEntitySet"));
Assert.NotNull(model.EntityContainer.Elements
.SingleOrDefault(e => e.Name == "TestEntitySet2"));
Assert.NotNull(model.EntityContainer.Elements
.SingleOrDefault(e => e.Name == "TestEntitySet3"));
}
public void ConfigurationWithProfilerReturnsProfiledHookPoints()
{
var configuration = new DomainConfiguration();
var profiler = new TestDomainProfiler();
configuration.AddHookPoint(typeof(IDomainProfiler), profiler);
// Profilers are not themselves profiled
Assert.Same(profiler, configuration
.GetHookPoints <IDomainProfiler>().Single());
var singletonHookPoint = new object();
var singletonHookPointProfiled = new object();
profiler.RegisterProfiledInstance(
singletonHookPoint, singletonHookPointProfiled);
configuration.SetHookPoint(typeof(object), singletonHookPoint);
Assert.Same(singletonHookPointProfiled,
configuration.GetHookPoint <object>());
var multiCastHookPoint = new object();
var multiCastHookPointProfiled = new object();
profiler.RegisterProfiledInstance(
multiCastHookPoint, multiCastHookPointProfiled);
configuration.AddHookPoint(typeof(object), multiCastHookPoint);
Assert.True(configuration.GetHookPoints <object>()
.SequenceEqual(new object[] { multiCastHookPointProfiled }));
}
public void ConfigurationRegistersHookPointsCorrectly()
{
var configuration = new DomainConfiguration();
Assert.False(configuration.HasHookPoint(typeof(object)));
Assert.Null(configuration.GetHookPoint <object>());
Assert.False(configuration.HasHookPoints(typeof(object)));
Assert.False(configuration.GetHookPoints <object>().Any());
var singletonHookPoint = new object();
configuration.SetHookPoint(typeof(object), singletonHookPoint);
Assert.True(configuration.HasHookPoint(typeof(object)));
Assert.Same(singletonHookPoint,
configuration.GetHookPoint <object>());
Assert.False(configuration.HasHookPoints(typeof(object)));
Assert.False(configuration.GetHookPoints <object>().Any());
var multiCastHookPoint1 = new object();
configuration.AddHookPoint(typeof(object), multiCastHookPoint1);
Assert.Same(singletonHookPoint,
configuration.GetHookPoint <object>());
Assert.True(configuration.HasHookPoints(typeof(object)));
Assert.True(configuration.GetHookPoints <object>()
.SequenceEqual(new object[] { multiCastHookPoint1 }));
var multiCastHookPoint2 = new object();
configuration.AddHookPoint(typeof(object), multiCastHookPoint2);
Assert.True(configuration.HasHookPoints(typeof(object)));
Assert.True(configuration.GetHookPoints <object>()
.SequenceEqual(new object[] { multiCastHookPoint1, multiCastHookPoint2 }));
}
/// <summary>
/// Enables principal-supplied role-based security for a domain.
/// </summary>
/// <param name="configuration">
/// A domain configuration.
/// </param>
/// <remarks>
/// This method adds hook points to the domain configuration that
/// authorize according to roles assigned to the current principal
/// along with any that have been asserted during a domain flow.
/// </remarks>
public static void EnableRoleBasedSecurity(
this DomainConfiguration configuration)
{
Ensure.NotNull(configuration, "configuration");
configuration.AddHookPoint(
typeof(IModelVisibilityFilter),
RoleBasedAuthorization.Default);
configuration.AddHookPoint(
typeof(IQueryExpressionInspector),
RoleBasedAuthorization.Default);
}
/// <inheritdoc/>
public static void ApplyTo(
DomainConfiguration configuration,
Type targetType)
{
Ensure.NotNull(configuration, "configuration");
Ensure.NotNull(targetType, "targetType");
var provider = new ConventionalEntitySetProvider(targetType);
configuration.AddHookPoint(typeof(IModelExtender), provider);
configuration.AddHookPoint(typeof(IModelMapper), provider);
configuration.AddHookPoint(typeof(IQueryExpressionExpander), provider);
}
/// <inheritdoc/>
public static void ApplyTo(
DomainConfiguration configuration,
Type targetType)
{
Ensure.NotNull(configuration, "configuration");
Ensure.NotNull(targetType, "targetType");
var provider = new ConventionalEntitySetProvider(targetType);
configuration.AddHookPoint(typeof(IModelExtender), provider);
configuration.AddHookPoint(typeof(IModelMapper), provider);
configuration.AddHookPoint(typeof(IQueryExpressionExpander), provider);
}
public void SourceOfComposableFunctionIsCorrect()
{
var configuration = new DomainConfiguration();
var modelMapper = new TestModelMapper();
configuration.AddHookPoint(typeof(IModelMapper), modelMapper);
configuration.EnsureCommitted();
var context = new DomainContext(configuration);
var arguments = new object[0];
var source = Domain.Source(context,
"Namespace", "Function", arguments);
Assert.Equal(typeof(DateTime), source.ElementType);
Assert.True(source.Expression is MethodCallExpression);
var methodCall = source.Expression as MethodCallExpression;
Assert.Null(methodCall.Object);
Assert.Equal(typeof(DomainData), methodCall.Method.DeclaringType);
Assert.Equal("Source", methodCall.Method.Name);
Assert.Equal(typeof(DateTime), methodCall.Method.GetGenericArguments()[0]);
Assert.Equal(3, methodCall.Arguments.Count);
Assert.True(methodCall.Arguments[0] is ConstantExpression);
Assert.Equal("Namespace", (methodCall.Arguments[0] as ConstantExpression).Value);
Assert.True(methodCall.Arguments[1] is ConstantExpression);
Assert.Equal("Function", (methodCall.Arguments[1] as ConstantExpression).Value);
Assert.True(methodCall.Arguments[2] is ConstantExpression);
Assert.Equal(arguments, (methodCall.Arguments[2] as ConstantExpression).Value);
Assert.Equal(source.Expression.ToString(), source.ToString());
}
public void CommittedConfigurationCannotAddHookPoint()
{
var configuration = new DomainConfiguration();
configuration.EnsureCommitted();
Assert.Throws <InvalidOperationException>(() => configuration.AddHookPoint(typeof(object), new object()));
}
public override void Configure(
DomainConfiguration configuration,
Type type)
{
enableConventionsAttribute.Configure(configuration, type);
ConventionalActionProvider.ApplyTo(configuration, type);
configuration.AddHookPoint(typeof(IModelExtender), new CustomExtender());
}
/// <inheritdoc/>
public static void ApplyTo(
DomainConfiguration configuration,
Type targetType)
{
Ensure.NotNull(configuration, "configuration");
Ensure.NotNull(targetType, "targetType");
configuration.AddHookPoint(
typeof(IChangeSetEntryFilter),
new ConventionalChangeSetEntryFilter(targetType));
}
/// <inheritdoc/>
public static void ApplyTo(
DomainConfiguration configuration,
Type targetType)
{
Ensure.NotNull(configuration, "configuration");
Ensure.NotNull(targetType, "targetType");
configuration.AddHookPoint(
typeof(IQueryExpressionFilter),
new ConventionalEntitySetFilter(targetType));
}
/// <inheritdoc/>
public static void ApplyTo(
DomainConfiguration configuration,
Type targetType)
{
Ensure.NotNull(configuration, "configuration");
Ensure.NotNull(targetType, "targetType");
configuration.AddHookPoint(
typeof(IQueryExpressionFilter),
new ConventionalEntitySetFilter(targetType));
}
/// <inheritdoc/>
public static void ApplyTo(
DomainConfiguration configuration,
Type targetType)
{
Ensure.NotNull(configuration, "configuration");
Ensure.NotNull(targetType, "targetType");
configuration.AddHookPoint(
typeof(IChangeSetEntryAuthorizer),
new ConventionalChangeSetAuthorizer(targetType));
}
/// <summary>
/// Enables code-based conventions for a domain.
/// </summary>
/// <param name="configuration">
/// A domain configuration.
/// </param>
/// <param name="targetType">
/// The type of a class on which code-based conventions are used.
/// </param>
/// <remarks>
/// This method adds hook points to the domain configuration that
/// inspect a target type for a variety of code-based conventions
/// such as usage of specific attributes or members that follow
/// certain naming conventions.
/// </remarks>
public static void EnableConventions(
this DomainConfiguration configuration,
Type targetType)
{
Ensure.NotNull(configuration, "configuration");
Ensure.NotNull(targetType, "targetType");
ConventionalChangeSetAuthorizer.ApplyTo(configuration, targetType);
ConventionalChangeSetEntryFilter.ApplyTo(configuration, targetType);
configuration.AddHookPoint(typeof(IChangeSetEntryValidator), ConventionalChangeSetEntryValidator.Instance);
ConventionalEntitySetProvider.ApplyTo(configuration, targetType);
ConventionalModelExtender.ApplyTo(configuration, targetType);
ConventionalEntitySetFilter.ApplyTo(configuration, targetType);
}
public void InvocationContextGetsHookPointsCorrectly()
{
var configuration = new DomainConfiguration();
var singletonHookPoint = new object();
configuration.SetHookPoint(typeof(object), singletonHookPoint);
var multiCastHookPoint = new object();
configuration.AddHookPoint(typeof(object), multiCastHookPoint);
configuration.EnsureCommitted();
var domainContext = new DomainContext(configuration);
var context = new InvocationContext(domainContext);
Assert.Same(singletonHookPoint, context.GetHookPoint<object>());
Assert.True(context.GetHookPoints<object>()
.SequenceEqual(new object[] { multiCastHookPoint }));
}
public void InvocationContextGetsHookPointsCorrectly()
{
var configuration = new DomainConfiguration();
var singletonHookPoint = new object();
configuration.SetHookPoint(typeof(object), singletonHookPoint);
var multiCastHookPoint = new object();
configuration.AddHookPoint(typeof(object), multiCastHookPoint);
configuration.EnsureCommitted();
var domainContext = new DomainContext(configuration);
var context = new InvocationContext(domainContext);
Assert.Same(singletonHookPoint, context.GetHookPoint <object>());
Assert.True(context.GetHookPoints <object>()
.SequenceEqual(new object[] { multiCastHookPoint }));
}
public void DerivedConfigurationIsConfiguredCorrectly()
{
var baseConfig = new DomainConfiguration();
var derivedConfig = new DomainConfiguration(baseConfig);
Assert.Same(baseConfig, derivedConfig.BaseConfiguration);
Assert.False(derivedConfig.HasProperty("Test"));
Assert.Null(derivedConfig.GetProperty <string>("Test"));
baseConfig.SetProperty("Test", "Test");
Assert.True(derivedConfig.HasProperty("Test"));
Assert.Equal("Test", derivedConfig.GetProperty <string>("Test"));
derivedConfig.SetProperty("Test", "Test2");
Assert.True(derivedConfig.HasProperty("Test"));
Assert.Equal("Test2", derivedConfig.GetProperty <string>("Test"));
Assert.Equal("Test", baseConfig.GetProperty <string>("Test"));
derivedConfig.ClearProperty("Test");
Assert.True(derivedConfig.HasProperty("Test"));
Assert.Equal("Test", derivedConfig.GetProperty <string>("Test"));
var singletonHookPoint = new object();
baseConfig.SetHookPoint(typeof(object), singletonHookPoint);
Assert.True(derivedConfig.HasHookPoint(typeof(object)));
Assert.Same(singletonHookPoint,
derivedConfig.GetHookPoint <object>());
var derivedSingletonHookPoint = new object();
derivedConfig.SetHookPoint(typeof(object), derivedSingletonHookPoint);
Assert.True(derivedConfig.HasHookPoint(typeof(object)));
Assert.Same(derivedSingletonHookPoint,
derivedConfig.GetHookPoint <object>());
Assert.Same(singletonHookPoint,
baseConfig.GetHookPoint <object>());
var multiCastHookPoint1 = new object();
baseConfig.AddHookPoint(typeof(object), multiCastHookPoint1);
Assert.True(derivedConfig.HasHookPoints(typeof(object)));
Assert.True(derivedConfig.GetHookPoints <object>()
.SequenceEqual(new object[] { multiCastHookPoint1 }));
var multiCastHookPoint2 = new object();
derivedConfig.AddHookPoint(typeof(object), multiCastHookPoint2);
Assert.True(derivedConfig.HasHookPoints(typeof(object)));
Assert.True(derivedConfig.GetHookPoints <object>()
.SequenceEqual(new object[] { multiCastHookPoint1, multiCastHookPoint2 }));
Assert.True(baseConfig.GetHookPoints <object>()
.SequenceEqual(new object[] { multiCastHookPoint1 }));
var multiCastHookPoint3 = new object();
baseConfig.AddHookPoint(typeof(object), multiCastHookPoint3);
Assert.True(derivedConfig.HasHookPoints(typeof(object)));
Assert.True(derivedConfig.GetHookPoints <object>()
.SequenceEqual(new object[] { multiCastHookPoint1, multiCastHookPoint3, multiCastHookPoint2 }));
Assert.True(baseConfig.GetHookPoints <object>()
.SequenceEqual(new object[] { multiCastHookPoint1, multiCastHookPoint3 }));
}
/// <summary>
/// Apply a <see cref="ConventionalModelExtender"/> instance to the <see cref="DomainConfiguration"/>.
/// </summary>
/// <param name="configuration">The domain configuration.</param>
/// <param name="targetType">The target type on which to invoke model extending.</param>
public static void ApplyTo(DomainConfiguration configuration, Type targetType)
{
Ensure.NotNull(configuration, "configuration");
Ensure.NotNull(targetType, "targetType");
configuration.AddHookPoint(typeof(IModelExtender), new ConventionalModelExtender(targetType));
}
public static void ApplyTo(DomainConfiguration configuration, Type targetType)
{
ConventionalActionProvider provider = new ConventionalActionProvider(targetType);
configuration.AddHookPoint(typeof(IModelExtender), provider);
}
public static void ApplyTo(DomainConfiguration configuration, Type targetType)
{
ConventionalActionProvider provider = new ConventionalActionProvider(targetType);
configuration.AddHookPoint(typeof(IModelExtender), provider);
}
public void ConfigurationCannotAddHookPointOfWrongType()
{
var configuration = new DomainConfiguration();
Assert.Throws <ArgumentException>(() => configuration.AddHookPoint(typeof(IDisposable), new object()));
}
/// <summary>
/// Apply a <see cref="ConventionalModelExtender"/> instance to the <see cref="DomainConfiguration"/>.
/// </summary>
/// <param name="configuration">The domain configuration.</param>
/// <param name="targetType">The target type on which to invoke model extending.</param>
public static void ApplyTo(DomainConfiguration configuration, Type targetType)
{
Ensure.NotNull(configuration, "configuration");
Ensure.NotNull(targetType, "targetType");
configuration.AddHookPoint(typeof(IModelExtender), new ConventionalModelExtender(targetType));
}
public async Task GetModelUsingDefaultModelHandler()
{
var configuration = new DomainConfiguration();
configuration.SetHookPoint(
typeof(IModelProducer), new TestModelProducer());
configuration.AddHookPoint(
typeof(IModelExtender), new TestModelExtender(2));
configuration.AddHookPoint(
typeof(IModelExtender), new TestModelExtender(3));
configuration.AddHookPoint(
typeof(IModelVisibilityFilter),
new TestModelVisibilityFilter());
configuration.EnsureCommitted();
var context = new DomainContext(configuration);
var model = await Domain.GetModelAsync(context);
Assert.Equal(3, model.SchemaElements.Count());
Assert.Null(model.SchemaElements
.SingleOrDefault(e => e.Name == "TestName"));
Assert.NotNull(model.SchemaElements
.SingleOrDefault(e => e.Name == "TestName2"));
Assert.NotNull(model.SchemaElements
.SingleOrDefault(e => e.Name == "TestName3"));
Assert.NotNull(model.EntityContainer);
Assert.Null(model.EntityContainer.Elements
.SingleOrDefault(e => e.Name == "TestEntitySet"));
Assert.NotNull(model.EntityContainer.Elements
.SingleOrDefault(e => e.Name == "TestEntitySet2"));
Assert.NotNull(model.EntityContainer.Elements
.SingleOrDefault(e => e.Name == "TestEntitySet3"));
}
