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")); }